package com.example.demo;

/**
 * @Author lizhien (zhien.li@nascent.cn)
 * @Date 2020/8/4 19:51
 * @Version 1.0.0
 * @Description com.example.demo
 */

import java.text.SimpleDateFormat;
import java.util.Date;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.DeliveryMode;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.ScheduledMessage;

public class Producer {

    //设置发布地址为默认的URL地址
    private static final String BROKER_URL = "failover:(nio://localhost:61616)?randomize=true";//ActiveMQConnection.DEFAULT_BROKER_URL;
    private Connection connection;
    private MessageProducer producer;
    private Session session;

    public Producer() throws JMSException {
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(BROKER_URL);

        //创建从工厂连接中得到的对象
        connection = connectionFactory.createConnection();
        connection.start();

        //fasle：参数表示为非事务类型；AUTO_ACNOWLEDGE：消息自动确认
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Destination destination = session.createQueue("hello.queue3");
        producer = session.createProducer(destination);
        //设置消息非持久化（学习用法）
        producer.setDeliveryMode(DeliveryMode.PERSISTENT);
    }

    public void sendMessage(String i) throws JMSException {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String nowTime = df.format(new Date());
        String text = "为容器管理资源当你定义Pod时可以选择性地为每个容器设定所需要的资源数量。"; //最常见的可设定资源是CPU和内存（RAM）大小；此外还有其他类型的资源。当你为Pod中的Container指定了资源请求时，调度器就利用该信息决定将Pod调度到哪个节点上。当你还为Container指定了资源约束时，kubelet就可以确保运行的容器不会使用超出所设约束的资源。kubelet还会为容器预留所请求数量的系统资源，供其使用。请求和约束如果Pod运行所在的节点具有足够的可用资源，容器可能（且可以）使用超出对应资源request属性所设置的资源量。不过，容器不可以使用超出其资源limit属性所设置的资源量。例如，如果你将容器的memory的请求量设置为256MiB，而该容器所处的Pod被调度到一个具有8GiB内存的节点上，并且该节点上没有其他Pods运行，那么该容器就可以尝试使用更多的内存。如果你将某容器的memory约束设置为4GiB，kubelet（和容器运行时）就会确保该约束生效。容器运行时会禁止容器使用超出所设置资源约束的资源。例如：当容器中进程尝试使用超出所允许内存量的资源时，系统内核会将尝试申请内存的进程终止，并引发内存不足（OOM）错误。约束值可以以被动方式来实现（系统会在发现违例时进行干预），或者通过强制生效的方式实现（系统会避免容器用量超出约束值）。不同的容器运行时采用不同方式来实现相同的限制。说明：如果某Container设置了自己的内存限制但未设置内存请求，Kubernetes自动为其设置与内存限制相匹配的请求值。类似的，如果某Container设置了CPU限制值但未设置CPU请求值，则Kubernetes自动为其设置CPU请求并使之与CPU限制值匹配。资源类型CPU和内存都是资源类型。每种资源类型具有其基本单位。CPU表达的是计算处理能力，其单位是KubernetesCPUs。内存的单位是字节。如果你使用的是Kubernetesv1.14或更高版本，则可以指定巨页（HugePage）资源。巨页是Linux特有的功能，节点内核在其中分配的内存块比默认页大小大得多。例如，在默认页面大小为4KiB的系统上，你可以指定约束hugepages-2Mi:80Mi。如果容器尝试分配40个2MiB大小的巨页（总共80MiB），则分配请求会失败。说明：你不能过量使用hugepages-*资源。这与memory和cpu资源不同。CPU和内存统称为计算资源，或简称为资源。计算资源的数量是可测量的，可以被请求、被分配、被消耗。它们与API资源不同。API资源（如Pod和Service）是可通过KubernetesAPI服务器读取和修改的对象。Pod和容器的资源请求和约束Pod中的每个容器都可以指定以下的一个或者多个值：spec.containers[].resources.limits.cpuspec.containers[].resources.limits.memoryspec.containers[].resources.limits.hugepages-<size>spec.containers[].resources.requests.cpuspec.containers[].resources.requests.memoryspec.containers[].resources.requests.hugepages-<size>尽管请求和限制值只能在单个容器上指定，我们仍可方便地计算出Pod的资源请求和约束。Pod对特定资源类型的请求/约束值是Pod中各容器对该类型资源的请求/约束值的总和。Kubernetes中的资源单位CPU的含义CPU资源的约束和请求以CPU为单位。Kubernetes中的一个CPU等于云平台上的1个vCPU/核和裸机Intel处理器上的1个超线程。你也可以表达带小数CPU的请求。spec.containers[].resources.requests.cpu为0.5的Container肯定能够获得请求1CPU的容器的一半CPU资源。表达式0.1等价于表达式100m，可以看作“100millicpu”。有些人说成是“一百毫cpu”，其实说的是同样的事情。具有小数点（如0.1）的请求由API转换为100m；最大精度是1m。因此，或许你应该优先考虑使用100m的形式。CPU总是按绝对数量来请求的，不可以使用相对数量；0.1的CPU在单核、双核、48核的机器上的意义是一样的。内存的含义内存的约束和请求以字节为单位。你可以使用以下后缀之一以一般整数或定点数字形式来表示内存：E、P、T、G、M、k。你也可以使用对应的2的幂数：Ei、Pi、Ti、Gi、Mi、Ki。例如，以下表达式所代表的是大致相同的值：128974848、129e6、129M、123Mi下面是个例子。以下Pod有两个Container。每个Container的请求为0.25cpu和64MiB（226字节）内存，每个容器的资源约束为0.5cpu和128MiB内存。你可以认为该Pod的资源请求为0.5cpu和128MiB内存，资源限制为1cpu和256MiB内存。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4env:-name:MYSQL_ROOT_PASSWORDvalue:passwordresources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m带资源请求的Pod如何调度当你创建一个Pod时，Kubernetes调度程序将为Pod选择一个节点。每个节点对每种资源类型都有一个容量上限：可为Pod提供的CPU和内存量。调度程序确保对于每种资源类型，所调度的容器的资源请求的总和小于节点的容量。请注意，尽管节点上的实际内存或CPU资源使用量非常低，如果容量检查失败，调度程序仍会拒绝在该节点上放置Pod。当稍后节点上资源用量增加，例如到达请求率的每日峰值区间时，节点上也不会出现资源不足的问题。带资源约束的Pod如何运行当kubelet启动Pod中的Container时，它会将CPU和内存约束信息传递给容器运行时。当使用Docker时：spec.containers[].resources.requests.cpu先被转换为可能是小数的基础值，再乘以1024。这个数值和2的较大者用作dockerrun命令中的--cpu-shares标志的值。spec.containers[].resources.limits.cpu先被转换为millicore值，再乘以100。其结果就是每100毫秒内容器可以使用的CPU时间总量，单位为微秒。在此期间（100ms），容器所使用的CPU时间不可以超过它被分配的时间。说明：默认的配额（Quota）周期为100毫秒。CPU配额的最小精度为1毫秒。spec.containers[].resources.limits.memory被转换为整数值，作为dockerrun命令中的--memory参数值。如果Container超过其内存限制，则可能会被终止。如果容器可重新启动，则与所有其他类型的运行时失效一样，kubelet将重新启动容器。如果一个Container内存用量超过其内存请求值，那么当节点内存不足时，容器所处的Pod可能被逐出。每个Container可能被允许也可能不被允许使用超过其CPU约束的处理时间。但是，容器不会由于CPU使用率过高而被杀死。要确定Container是否会由于资源约束而无法调度或被杀死，请参阅疑难解答部分。监控计算和内存资源用量Pod的资源使用情况是作为Pod状态的一部分来报告的。如果为集群配置了可选的监控工具，则可以直接从指标API或者监控工具获得Pod的资源使用情况。本地临时存储FEATURESTATE:Kubernetesv1.10[beta]节点通常还可以具有本地的临时性存储，由本地挂接的可写入设备或者有时也用RAM来提供支持。“临时（Ephemeral）”意味着对所存储的数据不提供长期可用性的保证。Pods通常可以使用临时性本地存储来实现缓冲区、保存日志等功能。kubelet可以为使用本地临时存储的Pods提供这种存储空间，允许后者使用emptyDir类型的卷将其挂载到容器中。kubelet也使用此类存储来保存节点层面的容器日志，容器镜像文件、以及运行中容器的可写入层。注意：如果节点失效，存储在临时性存储中的数据会丢失。你的应用不能对本地临时性存储的性能SLA（例如磁盘IOPS）作任何假定。作为一种beta阶段功能特性，Kubernetes允许你跟踪、预留和限制Pod可消耗的临时性本地存储数量。本地临时性存储的配置Kubernetes有两种方式支持节点上配置本地临时性存储：单一文件系统双文件系统采用这种配置时，你会把所有类型的临时性本地数据（包括emptyDir卷、可写入容器层、容器镜像、日志等）放到同一个文件系统中。作为最有效的kubelet配置方式，这意味着该文件系统是专门提供给Kubernetes（kubelet）来保存数据的。kubelet也会生成节点层面的容器日志，并按临时性本地存储的方式对待之。kubelet会将日志写入到所配置的日志目录（默认为/var/log）下的文件中；还会针对其他本地存储的数据使用同一个基础目录（默认为/var/lib/kubelet）。通常，/var/lib/kubelet和/var/log都是在系统的根文件系统中。kubelet的设计也考虑到这一点。你的集群节点当然可以包含其他的、并非用于Kubernetes的很多文件系统。kubelet能够度量其本地存储的用量。实现度量机制的前提是：LocalStorageCapacityIsolation特性门控被启用（默认状态），并且你已经对节点进行了配置，使之使用所支持的本地临时性储存配置方式之一如果你的节点配置不同于以上预期，kubelet就无法对临时性本地存储的资源约束实施限制。说明：kubelet会将tmpfsemptyDir卷的用量当作容器内存用量，而不是本地临时性存储来统计。为本地临时性存储设置请求和约束值你可以使用ephemeral-storage来管理本地临时性存储。Pod中的每个Container可以设置以下属性：spec.containers[].resources.limits.ephemeral-storagespec.containers[].resources.requests.ephemeral-storageephemeral-storage的请求和约束值是按字节计量的。你可以使用一般整数或者定点数字加上下面的后缀来表达存储量：E、P、T、G、M、K。你也可以使用对应的2的幂级数来表达：Ei、Pi、Ti、Gi、Mi、Ki。例如，下面的表达式所表达的大致是同一个值：128974848,129e6,129M,123Mi在下面的例子中，Pod包含两个Container。每个Container请求2GiB大小的本地临时性存储。每个Container都设置了4GiB作为其本地临时性存储的约束值。因此，整个Pod的本地临时性存储请求是4GiB，且其本地临时性存储的约束为8GiB。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmp-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmpvolumes:-name:ephemeralemptyDir:{}带临时性存储的Pods的调度行为当你创建一个Pod时，Kubernetes调度器会为Pod选择一个节点来运行之。每个节点都有一个本地临时性存储的上限，是其可提供给Pods使用的总量。欲了解更多信息，可参考节点可分配资源节。调度器会确保所调度的Containers的资源请求总和不会超出节点的资源容量。临时性存储消耗的管理如果kubelet将本地临时性存储作为资源来管理，则kubelet会度量以下各处的存储用量：emptyDir卷，除了tmpfsemptyDir卷保存节点层面日志的目录可写入的容器镜像层如果某Pod的临时存储用量超出了你所允许的范围，kubelet会向其发出逐出（eviction）信号，触发该Pod被逐出所在节点。就容器层面的隔离而言，如果某容器的可写入镜像层和日志用量超出其存储约束，kubelet也会将所在的Pod标记为逐出候选。就Pod层面的隔离而言，kubelet会将Pod中所有容器的约束值相加，得到Pod存储约束的总值。如果所有容器的本地临时性存储用量总和加上Pod的emptyDir卷的用量超出Pod存储约束值，kubelet也会将该Pod标记为逐出候选。注意：如果kubelet没有度量本地临时性存储的用量，即使Pod的本地存储用量超出其约束值也不会被逐出。不过，如果用于可写入容器镜像层、节点层面日志或者emptyDir卷的文件系统中可用空间太少，节点会为自身设置本地存储不足的污点标签。这一污点会触发对那些无法容忍该污点的Pods的逐出操作。关于临时性本地存储的配置信息，请参考这里kubelet支持使用不同方式来度量Pod的存储用量：周期性扫描文件系统项目配额kubelet按预定周期执行扫描操作，检查emptyDir卷、容器日志目录以及可写入容器镜像层。这一扫描会度量存储空间用量。说明：在这种模式下，kubelet并不检查已删除文件所对应的、仍处于打开状态的文件描述符。如果你（或者容器）在emptyDir卷中创建了一个文件，写入一些内容之后再次打开该文件并执行了删除操作，所删除文件对应的inode仍然存在，直到你关闭该文件为止。kubelet不会将该文件所占用的空间视为已使用空间。为容器管理资源当你定义Pod时可以选择性地为每个容器设定所需要的资源数量。最常见的可设定资源是CPU和内存（RAM）大小；此外还有其他类型的资源。当你为Pod中的Container指定了资源请求时，调度器就利用该信息决定将Pod调度到哪个节点上。当你还为Container指定了资源约束时，kubelet就可以确保运行的容器不会使用超出所设约束的资源。kubelet还会为容器预留所请求数量的系统资源，供其使用。请求和约束如果Pod运行所在的节点具有足够的可用资源，容器可能（且可以）使用超出对应资源request属性所设置的资源量。不过，容器不可以使用超出其资源limit属性所设置的资源量。例如，如果你将容器的memory的请求量设置为256MiB，而该容器所处的Pod被调度到一个具有8GiB内存的节点上，并且该节点上没有其他Pods运行，那么该容器就可以尝试使用更多的内存。如果你将某容器的memory约束设置为4GiB，kubelet（和容器运行时）就会确保该约束生效。容器运行时会禁止容器使用超出所设置资源约束的资源。例如：当容器中进程尝试使用超出所允许内存量的资源时，系统内核会将尝试申请内存的进程终止，并引发内存不足（OOM）错误。约束值可以以被动方式来实现（系统会在发现违例时进行干预），或者通过强制生效的方式实现（系统会避免容器用量超出约束值）。不同的容器运行时采用不同方式来实现相同的限制。说明：如果某Container设置了自己的内存限制但未设置内存请求，Kubernetes自动为其设置与内存限制相匹配的请求值。类似的，如果某Container设置了CPU限制值但未设置CPU请求值，则Kubernetes自动为其设置CPU请求并使之与CPU限制值匹配。资源类型CPU和内存都是资源类型。每种资源类型具有其基本单位。CPU表达的是计算处理能力，其单位是KubernetesCPUs。内存的单位是字节。如果你使用的是Kubernetesv1.14或更高版本，则可以指定巨页（HugePage）资源。巨页是Linux特有的功能，节点内核在其中分配的内存块比默认页大小大得多。例如，在默认页面大小为4KiB的系统上，你可以指定约束hugepages-2Mi:80Mi。如果容器尝试分配40个2MiB大小的巨页（总共80MiB），则分配请求会失败。说明：你不能过量使用hugepages-*资源。这与memory和cpu资源不同。CPU和内存统称为计算资源，或简称为资源。计算资源的数量是可测量的，可以被请求、被分配、被消耗。它们与API资源不同。API资源（如Pod和Service）是可通过KubernetesAPI服务器读取和修改的对象。Pod和容器的资源请求和约束Pod中的每个容器都可以指定以下的一个或者多个值：spec.containers[].resources.limits.cpuspec.containers[].resources.limits.memoryspec.containers[].resources.limits.hugepages-<size>spec.containers[].resources.requests.cpuspec.containers[].resources.requests.memoryspec.containers[].resources.requests.hugepages-<size>尽管请求和限制值只能在单个容器上指定，我们仍可方便地计算出Pod的资源请求和约束。Pod对特定资源类型的请求/约束值是Pod中各容器对该类型资源的请求/约束值的总和。Kubernetes中的资源单位CPU的含义CPU资源的约束和请求以CPU为单位。Kubernetes中的一个CPU等于云平台上的1个vCPU/核和裸机Intel处理器上的1个超线程。你也可以表达带小数CPU的请求。spec.containers[].resources.requests.cpu为0.5的Container肯定能够获得请求1CPU的容器的一半CPU资源。表达式0.1等价于表达式100m，可以看作“100millicpu”。有些人说成是“一百毫cpu”，其实说的是同样的事情。具有小数点（如0.1）的请求由API转换为100m；最大精度是1m。因此，或许你应该优先考虑使用100m的形式。CPU总是按绝对数量来请求的，不可以使用相对数量；0.1的CPU在单核、双核、48核的机器上的意义是一样的。内存的含义内存的约束和请求以字节为单位。你可以使用以下后缀之一以一般整数或定点数字形式来表示内存：E、P、T、G、M、k。你也可以使用对应的2的幂数：Ei、Pi、Ti、Gi、Mi、Ki。例如，以下表达式所代表的是大致相同的值：128974848、129e6、129M、123Mi下面是个例子。以下Pod有两个Container。每个Container的请求为0.25cpu和64MiB（226字节）内存，每个容器的资源约束为0.5cpu和128MiB内存。你可以认为该Pod的资源请求为0.5cpu和128MiB内存，资源限制为1cpu和256MiB内存。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4env:-name:MYSQL_ROOT_PASSWORDvalue:passwordresources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m带资源请求的Pod如何调度当你创建一个Pod时，Kubernetes调度程序将为Pod选择一个节点。每个节点对每种资源类型都有一个容量上限：可为Pod提供的CPU和内存量。调度程序确保对于每种资源类型，所调度的容器的资源请求的总和小于节点的容量。请注意，尽管节点上的实际内存或CPU资源使用量非常低，如果容量检查失败，调度程序仍会拒绝在该节点上放置Pod。当稍后节点上资源用量增加，例如到达请求率的每日峰值区间时，节点上也不会出现资源不足的问题。带资源约束的Pod如何运行当kubelet启动Pod中的Container时，它会将CPU和内存约束信息传递给容器运行时。当使用Docker时：spec.containers[].resources.requests.cpu先被转换为可能是小数的基础值，再乘以1024。这个数值和2的较大者用作dockerrun命令中的--cpu-shares标志的值。spec.containers[].resources.limits.cpu先被转换为millicore值，再乘以100。其结果就是每100毫秒内容器可以使用的CPU时间总量，单位为微秒。在此期间（100ms），容器所使用的CPU时间不可以超过它被分配的时间。说明：默认的配额（Quota）周期为100毫秒。CPU配额的最小精度为1毫秒。spec.containers[].resources.limits.memory被转换为整数值，作为dockerrun命令中的--memory参数值。如果Container超过其内存限制，则可能会被终止。如果容器可重新启动，则与所有其他类型的运行时失效一样，kubelet将重新启动容器。如果一个Container内存用量超过其内存请求值，那么当节点内存不足时，容器所处的Pod可能被逐出。每个Container可能被允许也可能不被允许使用超过其CPU约束的处理时间。但是，容器不会由于CPU使用率过高而被杀死。要确定Container是否会由于资源约束而无法调度或被杀死，请参阅疑难解答部分。监控计算和内存资源用量Pod的资源使用情况是作为Pod状态的一部分来报告的。如果为集群配置了可选的监控工具，则可以直接从指标API或者监控工具获得Pod的资源使用情况。本地临时存储FEATURESTATE:Kubernetesv1.10[beta]节点通常还可以具有本地的临时性存储，由本地挂接的可写入设备或者有时也用RAM来提供支持。“临时（Ephemeral）”意味着对所存储的数据不提供长期可用性的保证。Pods通常可以使用临时性本地存储来实现缓冲区、保存日志等功能。kubelet可以为使用本地临时存储的Pods提供这种存储空间，允许后者使用emptyDir类型的卷将其挂载到容器中。kubelet也使用此类存储来保存节点层面的容器日志，容器镜像文件、以及运行中容器的可写入层。注意：如果节点失效，存储在临时性存储中的数据会丢失。你的应用不能对本地临时性存储的性能SLA（例如磁盘IOPS）作任何假定。作为一种beta阶段功能特性，Kubernetes允许你跟踪、预留和限制Pod可消耗的临时性本地存储数量。本地临时性存储的配置Kubernetes有两种方式支持节点上配置本地临时性存储：单一文件系统双文件系统采用这种配置时，你会把所有类型的临时性本地数据（包括emptyDir卷、可写入容器层、容器镜像、日志等）放到同一个文件系统中。作为最有效的kubelet配置方式，这意味着该文件系统是专门提供给Kubernetes（kubelet）来保存数据的。kubelet也会生成节点层面的容器日志，并按临时性本地存储的方式对待之。kubelet会将日志写入到所配置的日志目录（默认为/var/log）下的文件中；还会针对其他本地存储的数据使用同一个基础目录（默认为/var/lib/kubelet）。通常，/var/lib/kubelet和/var/log都是在系统的根文件系统中。kubelet的设计也考虑到这一点。你的集群节点当然可以包含其他的、并非用于Kubernetes的很多文件系统。kubelet能够度量其本地存储的用量。实现度量机制的前提是：LocalStorageCapacityIsolation特性门控被启用（默认状态），并且你已经对节点进行了配置，使之使用所支持的本地临时性储存配置方式之一如果你的节点配置不同于以上预期，kubelet就无法对临时性本地存储的资源约束实施限制。说明：kubelet会将tmpfsemptyDir卷的用量当作容器内存用量，而不是本地临时性存储来统计。为本地临时性存储设置请求和约束值你可以使用ephemeral-storage来管理本地临时性存储。Pod中的每个Container可以设置以下属性：spec.containers[].resources.limits.ephemeral-storagespec.containers[].resources.requests.ephemeral-storageephemeral-storage的请求和约束值是按字节计量的。你可以使用一般整数或者定点数字加上下面的后缀来表达存储量：E、P、T、G、M、K。你也可以使用对应的2的幂级数来表达：Ei、Pi、Ti、Gi、Mi、Ki。例如，下面的表达式所表达的大致是同一个值：128974848,129e6,129M,123Mi在下面的例子中，Pod包含两个Container。每个Container请求2GiB大小的本地临时性存储。每个Container都设置了4GiB作为其本地临时性存储的约束值。因此，整个Pod的本地临时性存储请求是4GiB，且其本地临时性存储的约束为8GiB。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmp-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmpvolumes:-name:ephemeralemptyDir:{}带临时性存储的Pods的调度行为当你创建一个Pod时，Kubernetes调度器会为Pod选择一个节点来运行之。每个节点都有一个本地临时性存储的上限，是其可提供给Pods使用的总量。欲了解更多信息，可参考节点可分配资源节。调度器会确保所调度的Containers的资源请求总和不会超出节点的资源容量。临时性存储消耗的管理如果kubelet将本地临时性存储作为资源来管理，则kubelet会度量以下各处的存储用量：emptyDir卷，除了tmpfsemptyDir卷保存节点层面日志的目录可写入的容器镜像层如果某Pod的临时存储用量超出了你所允许的范围，kubelet会向其发出逐出（eviction）信号，触发该Pod被逐出所在节点。就容器层面的隔离而言，如果某容器的可写入镜像层和日志用量超出其存储约束，kubelet也会将所在的Pod标记为逐出候选。就Pod层面的隔离而言，kubelet会将Pod中所有容器的约束值相加，得到Pod存储约束的总值。如果所有容器的本地临时性存储用量总和加上Pod的emptyDir卷的用量超出Pod存储约束值，kubelet也会将该Pod标记为逐出候选。注意：如果kubelet没有度量本地临时性存储的用量，即使Pod的本地存储用量超出其约束值也不会被逐出。不过，如果用于可写入容器镜像层、节点层面日志或者emptyDir卷的文件系统中可用空间太少，节点会为自身设置本地存储不足的污点标签。这一污点会触发对那些无法容忍该污点的Pods的逐出操作。关于临时性本地存储的配置信息，请参考这里kubelet支持使用不同方式来度量Pod的存储用量：周期性扫描文件系统项目配额kubelet按预定周期执行扫描操作，检查emptyDir卷、容器日志目录以及可写入容器镜像层。这一扫描会度量存储空间用量。说明：在这种模式下，kubelet并不检查已删除文件所对应的、仍处于打开状态的文件描述符。如果你（或者容器）在emptyDir卷中创建了一个文件，写入一些内容之后再次打开该文件并执行了删除操作，所删除文件对应的inode仍然存在，直到你关闭该文件为止。kubelet不会将该文件所占用的空间视为已使用空间。为容器管理资源当你定义Pod时可以选择性地为每个容器设定所需要的资源数量。最常见的可设定资源是CPU和内存（RAM）大小；此外还有其他类型的资源。当你为Pod中的Container指定了资源请求时，调度器就利用该信息决定将Pod调度到哪个节点上。当你还为Container指定了资源约束时，kubelet就可以确保运行的容器不会使用超出所设约束的资源。kubelet还会为容器预留所请求数量的系统资源，供其使用。请求和约束如果Pod运行所在的节点具有足够的可用资源，容器可能（且可以）使用超出对应资源request属性所设置的资源量。不过，容器不可以使用超出其资源limit属性所设置的资源量。例如，如果你将容器的memory的请求量设置为256MiB，而该容器所处的Pod被调度到一个具有8GiB内存的节点上，并且该节点上没有其他Pods运行，那么该容器就可以尝试使用更多的内存。如果你将某容器的memory约束设置为4GiB，kubelet（和容器运行时）就会确保该约束生效。容器运行时会禁止容器使用超出所设置资源约束的资源。例如：当容器中进程尝试使用超出所允许内存量的资源时，系统内核会将尝试申请内存的进程终止，并引发内存不足（OOM）错误。约束值可以以被动方式来实现（系统会在发现违例时进行干预），或者通过强制生效的方式实现（系统会避免容器用量超出约束值）。不同的容器运行时采用不同方式来实现相同的限制。说明：如果某Container设置了自己的内存限制但未设置内存请求，Kubernetes自动为其设置与内存限制相匹配的请求值。类似的，如果某Container设置了CPU限制值但未设置CPU请求值，则Kubernetes自动为其设置CPU请求并使之与CPU限制值匹配。资源类型CPU和内存都是资源类型。每种资源类型具有其基本单位。CPU表达的是计算处理能力，其单位是KubernetesCPUs。内存的单位是字节。如果你使用的是Kubernetesv1.14或更高版本，则可以指定巨页（HugePage）资源。巨页是Linux特有的功能，节点内核在其中分配的内存块比默认页大小大得多。例如，在默认页面大小为4KiB的系统上，你可以指定约束hugepages-2Mi:80Mi。如果容器尝试分配40个2MiB大小的巨页（总共80MiB），则分配请求会失败。说明：你不能过量使用hugepages-*资源。这与memory和cpu资源不同。CPU和内存统称为计算资源，或简称为资源。计算资源的数量是可测量的，可以被请求、被分配、被消耗。它们与API资源不同。API资源（如Pod和Service）是可通过KubernetesAPI服务器读取和修改的对象。Pod和容器的资源请求和约束Pod中的每个容器都可以指定以下的一个或者多个值：spec.containers[].resources.limits.cpuspec.containers[].resources.limits.memoryspec.containers[].resources.limits.hugepages-<size>spec.containers[].resources.requests.cpuspec.containers[].resources.requests.memoryspec.containers[].resources.requests.hugepages-<size>尽管请求和限制值只能在单个容器上指定，我们仍可方便地计算出Pod的资源请求和约束。Pod对特定资源类型的请求/约束值是Pod中各容器对该类型资源的请求/约束值的总和。Kubernetes中的资源单位CPU的含义CPU资源的约束和请求以CPU为单位。Kubernetes中的一个CPU等于云平台上的1个vCPU/核和裸机Intel处理器上的1个超线程。你也可以表达带小数CPU的请求。spec.containers[].resources.requests.cpu为0.5的Container肯定能够获得请求1CPU的容器的一半CPU资源。表达式0.1等价于表达式100m，可以看作“100millicpu”。有些人说成是“一百毫cpu”，其实说的是同样的事情。具有小数点（如0.1）的请求由API转换为100m；最大精度是1m。因此，或许你应该优先考虑使用100m的形式。CPU总是按绝对数量来请求的，不可以使用相对数量；0.1的CPU在单核、双核、48核的机器上的意义是一样的。内存的含义内存的约束和请求以字节为单位。你可以使用以下后缀之一以一般整数或定点数字形式来表示内存：E、P、T、G、M、k。你也可以使用对应的2的幂数：Ei、Pi、Ti、Gi、Mi、Ki。例如，以下表达式所代表的是大致相同的值：128974848、129e6、129M、123Mi下面是个例子。以下Pod有两个Container。每个Container的请求为0.25cpu和64MiB（226字节）内存，每个容器的资源约束为0.5cpu和128MiB内存。你可以认为该Pod的资源请求为0.5cpu和128MiB内存，资源限制为1cpu和256MiB内存。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4env:-name:MYSQL_ROOT_PASSWORDvalue:passwordresources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m带资源请求的Pod如何调度当你创建一个Pod时，Kubernetes调度程序将为Pod选择一个节点。每个节点对每种资源类型都有一个容量上限：可为Pod提供的CPU和内存量。调度程序确保对于每种资源类型，所调度的容器的资源请求的总和小于节点的容量。请注意，尽管节点上的实际内存或CPU资源使用量非常低，如果容量检查失败，调度程序仍会拒绝在该节点上放置Pod。当稍后节点上资源用量增加，例如到达请求率的每日峰值区间时，节点上也不会出现资源不足的问题。带资源约束的Pod如何运行当kubelet启动Pod中的Container时，它会将CPU和内存约束信息传递给容器运行时。当使用Docker时：spec.containers[].resources.requests.cpu先被转换为可能是小数的基础值，再乘以1024。这个数值和2的较大者用作dockerrun命令中的--cpu-shares标志的值。spec.containers[].resources.limits.cpu先被转换为millicore值，再乘以100。其结果就是每100毫秒内容器可以使用的CPU时间总量，单位为微秒。在此期间（100ms），容器所使用的CPU时间不可以超过它被分配的时间。说明：默认的配额（Quota）周期为100毫秒。CPU配额的最小精度为1毫秒。spec.containers[].resources.limits.memory被转换为整数值，作为dockerrun命令中的--memory参数值。如果Container超过其内存限制，则可能会被终止。如果容器可重新启动，则与所有其他类型的运行时失效一样，kubelet将重新启动容器。如果一个Container内存用量超过其内存请求值，那么当节点内存不足时，容器所处的Pod可能被逐出。每个Container可能被允许也可能不被允许使用超过其CPU约束的处理时间。但是，容器不会由于CPU使用率过高而被杀死。要确定Container是否会由于资源约束而无法调度或被杀死，请参阅疑难解答部分。监控计算和内存资源用量Pod的资源使用情况是作为Pod状态的一部分来报告的。如果为集群配置了可选的监控工具，则可以直接从指标API或者监控工具获得Pod的资源使用情况。本地临时存储FEATURESTATE:Kubernetesv1.10[beta]节点通常还可以具有本地的临时性存储，由本地挂接的可写入设备或者有时也用RAM来提供支持。“临时（Ephemeral）”意味着对所存储的数据不提供长期可用性的保证。Pods通常可以使用临时性本地存储来实现缓冲区、保存日志等功能。kubelet可以为使用本地临时存储的Pods提供这种存储空间，允许后者使用emptyDir类型的卷将其挂载到容器中。kubelet也使用此类存储来保存节点层面的容器日志，容器镜像文件、以及运行中容器的可写入层。注意：如果节点失效，存储在临时性存储中的数据会丢失。你的应用不能对本地临时性存储的性能SLA（例如磁盘IOPS）作任何假定。作为一种beta阶段功能特性，Kubernetes允许你跟踪、预留和限制Pod可消耗的临时性本地存储数量。本地临时性存储的配置Kubernetes有两种方式支持节点上配置本地临时性存储：单一文件系统双文件系统采用这种配置时，你会把所有类型的临时性本地数据（包括emptyDir卷、可写入容器层、容器镜像、日志等）放到同一个文件系统中。作为最有效的kubelet配置方式，这意味着该文件系统是专门提供给Kubernetes（kubelet）来保存数据的。kubelet也会生成节点层面的容器日志，并按临时性本地存储的方式对待之。kubelet会将日志写入到所配置的日志目录（默认为/var/log）下的文件中；还会针对其他本地存储的数据使用同一个基础目录（默认为/var/lib/kubelet）。通常，/var/lib/kubelet和/var/log都是在系统的根文件系统中。kubelet的设计也考虑到这一点。你的集群节点当然可以包含其他的、并非用于Kubernetes的很多文件系统。kubelet能够度量其本地存储的用量。实现度量机制的前提是：LocalStorageCapacityIsolation特性门控被启用（默认状态），并且你已经对节点进行了配置，使之使用所支持的本地临时性储存配置方式之一如果你的节点配置不同于以上预期，kubelet就无法对临时性本地存储的资源约束实施限制。说明：kubelet会将tmpfsemptyDir卷的用量当作容器内存用量，而不是本地临时性存储来统计。为本地临时性存储设置请求和约束值你可以使用ephemeral-storage来管理本地临时性存储。Pod中的每个Container可以设置以下属性：spec.containers[].resources.limits.ephemeral-storagespec.containers[].resources.requests.ephemeral-storageephemeral-storage的请求和约束值是按字节计量的。你可以使用一般整数或者定点数字加上下面的后缀来表达存储量：E、P、T、G、M、K。你也可以使用对应的2的幂级数来表达：Ei、Pi、Ti、Gi、Mi、Ki。例如，下面的表达式所表达的大致是同一个值：128974848,129e6,129M,123Mi在下面的例子中，Pod包含两个Container。每个Container请求2GiB大小的本地临时性存储。每个Container都设置了4GiB作为其本地临时性存储的约束值。因此，整个Pod的本地临时性存储请求是4GiB，且其本地临时性存储的约束为8GiB。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmp-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmpvolumes:-name:ephemeralemptyDir:{}带临时性存储的Pods的调度行为当你创建一个Pod时，Kubernetes调度器会为Pod选择一个节点来运行之。每个节点都有一个本地临时性存储的上限，是其可提供给Pods使用的总量。欲了解更多信息，可参考节点可分配资源节。调度器会确保所调度的Containers的资源请求总和不会超出节点的资源容量。临时性存储消耗的管理如果kubelet将本地临时性存储作为资源来管理，则kubelet会度量以下各处的存储用量：emptyDir卷，除了tmpfsemptyDir卷保存节点层面日志的目录可写入的容器镜像层如果某Pod的临时存储用量超出了你所允许的范围，kubelet会向其发出逐出（eviction）信号，触发该Pod被逐出所在节点。就容器层面的隔离而言，如果某容器的可写入镜像层和日志用量超出其存储约束，kubelet也会将所在的Pod标记为逐出候选。就Pod层面的隔离而言，kubelet会将Pod中所有容器的约束值相加，得到Pod存储约束的总值。如果所有容器的本地临时性存储用量总和加上Pod的emptyDir卷的用量超出Pod存储约束值，kubelet也会将该Pod标记为逐出候选。注意：如果kubelet没有度量本地临时性存储的用量，即使Pod的本地存储用量超出其约束值也不会被逐出。不过，如果用于可写入容器镜像层、节点层面日志或者emptyDir卷的文件系统中可用空间太少，节点会为自身设置本地存储不足的污点标签。这一污点会触发对那些无法容忍该污点的Pods的逐出操作。关于临时性本地存储的配置信息，请参考这里kubelet支持使用不同方式来度量Pod的存储用量：周期性扫描文件系统项目配额kubelet按预定周期执行扫描操作，检查emptyDir卷、容器日志目录以及可写入容器镜像层。这一扫描会度量存储空间用量。说明：在这种模式下，kubelet并不检查已删除文件所对应的、仍处于打开状态的文件描述符。如果你（或者容器）在emptyDir卷中创建了一个文件，写入一些内容之后再次打开该文件并执行了删除操作，所删除文件对应的inode仍然存在，直到你关闭该文件为止。kubelet不会将该文件所占用的空间视为已使用空间。为容器管理资源当你定义Pod时可以选择性地为每个容器设定所需要的资源数量。最常见的可设定资源是CPU和内存（RAM）大小；此外还有其他类型的资源。当你为Pod中的Container指定了资源请求时，调度器就利用该信息决定将Pod调度到哪个节点上。当你还为Container指定了资源约束时，kubelet就可以确保运行的容器不会使用超出所设约束的资源。kubelet还会为容器预留所请求数量的系统资源，供其使用。请求和约束如果Pod运行所在的节点具有足够的可用资源，容器可能（且可以）使用超出对应资源request属性所设置的资源量。不过，容器不可以使用超出其资源limit属性所设置的资源量。例如，如果你将容器的memory的请求量设置为256MiB，而该容器所处的Pod被调度到一个具有8GiB内存的节点上，并且该节点上没有其他Pods运行，那么该容器就可以尝试使用更多的内存。如果你将某容器的memory约束设置为4GiB，kubelet（和容器运行时）就会确保该约束生效。容器运行时会禁止容器使用超出所设置资源约束的资源。例如：当容器中进程尝试使用超出所允许内存量的资源时，系统内核会将尝试申请内存的进程终止，并引发内存不足（OOM）错误。约束值可以以被动方式来实现（系统会在发现违例时进行干预），或者通过强制生效的方式实现（系统会避免容器用量超出约束值）。不同的容器运行时采用不同方式来实现相同的限制。说明：如果某Container设置了自己的内存限制但未设置内存请求，Kubernetes自动为其设置与内存限制相匹配的请求值。类似的，如果某Container设置了CPU限制值但未设置CPU请求值，则Kubernetes自动为其设置CPU请求并使之与CPU限制值匹配。资源类型CPU和内存都是资源类型。每种资源类型具有其基本单位。CPU表达的是计算处理能力，其单位是KubernetesCPUs。内存的单位是字节。如果你使用的是Kubernetesv1.14或更高版本，则可以指定巨页（HugePage）资源。巨页是Linux特有的功能，节点内核在其中分配的内存块比默认页大小大得多。例如，在默认页面大小为4KiB的系统上，你可以指定约束hugepages-2Mi:80Mi。如果容器尝试分配40个2MiB大小的巨页（总共80MiB），则分配请求会失败。说明：你不能过量使用hugepages-*资源。这与memory和cpu资源不同。CPU和内存统称为计算资源，或简称为资源。计算资源的数量是可测量的，可以被请求、被分配、被消耗。它们与API资源不同。API资源（如Pod和Service）是可通过KubernetesAPI服务器读取和修改的对象。Pod和容器的资源请求和约束Pod中的每个容器都可以指定以下的一个或者多个值：spec.containers[].resources.limits.cpuspec.containers[].resources.limits.memoryspec.containers[].resources.limits.hugepages-<size>spec.containers[].resources.requests.cpuspec.containers[].resources.requests.memoryspec.containers[].resources.requests.hugepages-<size>尽管请求和限制值只能在单个容器上指定，我们仍可方便地计算出Pod的资源请求和约束。Pod对特定资源类型的请求/约束值是Pod中各容器对该类型资源的请求/约束值的总和。Kubernetes中的资源单位CPU的含义CPU资源的约束和请求以CPU为单位。Kubernetes中的一个CPU等于云平台上的1个vCPU/核和裸机Intel处理器上的1个超线程。你也可以表达带小数CPU的请求。spec.containers[].resources.requests.cpu为0.5的Container肯定能够获得请求1CPU的容器的一半CPU资源。表达式0.1等价于表达式100m，可以看作“100millicpu”。有些人说成是“一百毫cpu”，其实说的是同样的事情。具有小数点（如0.1）的请求由API转换为100m；最大精度是1m。因此，或许你应该优先考虑使用100m的形式。CPU总是按绝对数量来请求的，不可以使用相对数量；0.1的CPU在单核、双核、48核的机器上的意义是一样的。内存的含义内存的约束和请求以字节为单位。你可以使用以下后缀之一以一般整数或定点数字形式来表示内存：E、P、T、G、M、k。你也可以使用对应的2的幂数：Ei、Pi、Ti、Gi、Mi、Ki。例如，以下表达式所代表的是大致相同的值：128974848、129e6、129M、123Mi下面是个例子。以下Pod有两个Container。每个Container的请求为0.25cpu和64MiB（226字节）内存，每个容器的资源约束为0.5cpu和128MiB内存。你可以认为该Pod的资源请求为0.5cpu和128MiB内存，资源限制为1cpu和256MiB内存。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4env:-name:MYSQL_ROOT_PASSWORDvalue:passwordresources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m带资源请求的Pod如何调度当你创建一个Pod时，Kubernetes调度程序将为Pod选择一个节点。每个节点对每种资源类型都有一个容量上限：可为Pod提供的CPU和内存量。调度程序确保对于每种资源类型，所调度的容器的资源请求的总和小于节点的容量。请注意，尽管节点上的实际内存或CPU资源使用量非常低，如果容量检查失败，调度程序仍会拒绝在该节点上放置Pod。当稍后节点上资源用量增加，例如到达请求率的每日峰值区间时，节点上也不会出现资源不足的问题。带资源约束的Pod如何运行当kubelet启动Pod中的Container时，它会将CPU和内存约束信息传递给容器运行时。当使用Docker时：spec.containers[].resources.requests.cpu先被转换为可能是小数的基础值，再乘以1024。这个数值和2的较大者用作dockerrun命令中的--cpu-shares标志的值。spec.containers[].resources.limits.cpu先被转换为millicore值，再乘以100。其结果就是每100毫秒内容器可以使用的CPU时间总量，单位为微秒。在此期间（100ms），容器所使用的CPU时间不可以超过它被分配的时间。说明：默认的配额（Quota）周期为100毫秒。CPU配额的最小精度为1毫秒。spec.containers[].resources.limits.memory被转换为整数值，作为dockerrun命令中的--memory参数值。如果Container超过其内存限制，则可能会被终止。如果容器可重新启动，则与所有其他类型的运行时失效一样，kubelet将重新启动容器。如果一个Container内存用量超过其内存请求值，那么当节点内存不足时，容器所处的Pod可能被逐出。每个Container可能被允许也可能不被允许使用超过其CPU约束的处理时间。但是，容器不会由于CPU使用率过高而被杀死。要确定Container是否会由于资源约束而无法调度或被杀死，请参阅疑难解答部分。监控计算和内存资源用量Pod的资源使用情况是作为Pod状态的一部分来报告的。如果为集群配置了可选的监控工具，则可以直接从指标API或者监控工具获得Pod的资源使用情况。本地临时存储FEATURESTATE:Kubernetesv1.10[beta]节点通常还可以具有本地的临时性存储，由本地挂接的可写入设备或者有时也用RAM来提供支持。“临时（Ephemeral）”意味着对所存储的数据不提供长期可用性的保证。Pods通常可以使用临时性本地存储来实现缓冲区、保存日志等功能。kubelet可以为使用本地临时存储的Pods提供这种存储空间，允许后者使用emptyDir类型的卷将其挂载到容器中。kubelet也使用此类存储来保存节点层面的容器日志，容器镜像文件、以及运行中容器的可写入层。注意：如果节点失效，存储在临时性存储中的数据会丢失。你的应用不能对本地临时性存储的性能SLA（例如磁盘IOPS）作任何假定。作为一种beta阶段功能特性，Kubernetes允许你跟踪、预留和限制Pod可消耗的临时性本地存储数量。本地临时性存储的配置Kubernetes有两种方式支持节点上配置本地临时性存储：单一文件系统双文件系统采用这种配置时，你会把所有类型的临时性本地数据（包括emptyDir卷、可写入容器层、容器镜像、日志等）放到同一个文件系统中。作为最有效的kubelet配置方式，这意味着该文件系统是专门提供给Kubernetes（kubelet）来保存数据的。kubelet也会生成节点层面的容器日志，并按临时性本地存储的方式对待之。kubelet会将日志写入到所配置的日志目录（默认为/var/log）下的文件中；还会针对其他本地存储的数据使用同一个基础目录（默认为/var/lib/kubelet）。通常，/var/lib/kubelet和/var/log都是在系统的根文件系统中。kubelet的设计也考虑到这一点。你的集群节点当然可以包含其他的、并非用于Kubernetes的很多文件系统。kubelet能够度量其本地存储的用量。实现度量机制的前提是：LocalStorageCapacityIsolation特性门控被启用（默认状态），并且你已经对节点进行了配置，使之使用所支持的本地临时性储存配置方式之一如果你的节点配置不同于以上预期，kubelet就无法对临时性本地存储的资源约束实施限制。说明：kubelet会将tmpfsemptyDir卷的用量当作容器内存用量，而不是本地临时性存储来统计。为本地临时性存储设置请求和约束值你可以使用ephemeral-storage来管理本地临时性存储。Pod中的每个Container可以设置以下属性：spec.containers[].resources.limits.ephemeral-storagespec.containers[].resources.requests.ephemeral-storageephemeral-storage的请求和约束值是按字节计量的。你可以使用一般整数或者定点数字加上下面的后缀来表达存储量：E、P、T、G、M、K。你也可以使用对应的2的幂级数来表达：Ei、Pi、Ti、Gi、Mi、Ki。例如，下面的表达式所表达的大致是同一个值：128974848,129e6,129M,123Mi在下面的例子中，Pod包含两个Container。每个Container请求2GiB大小的本地临时性存储。每个Container都设置了4GiB作为其本地临时性存储的约束值。因此，整个Pod的本地临时性存储请求是4GiB，且其本地临时性存储的约束为8GiB。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmp-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmpvolumes:-name:ephemeralemptyDir:{}带临时性存储的Pods的调度行为当你创建一个Pod时，Kubernetes调度器会为Pod选择一个节点来运行之。每个节点都有一个本地临时性存储的上限，是其可提供给Pods使用的总量。欲了解更多信息，可参考节点可分配资源节。调度器会确保所调度的Containers的资源请求总和不会超出节点的资源容量。临时性存储消耗的管理如果kubelet将本地临时性存储作为资源来管理，则kubelet会度量以下各处的存储用量：emptyDir卷，除了tmpfsemptyDir卷保存节点层面日志的目录可写入的容器镜像层如果某Pod的临时存储用量超出了你所允许的范围，kubelet会向其发出逐出（eviction）信号，触发该Pod被逐出所在节点。就容器层面的隔离而言，如果某容器的可写入镜像层和日志用量超出其存储约束，kubelet也会将所在的Pod标记为逐出候选。就Pod层面的隔离而言，kubelet会将Pod中所有容器的约束值相加，得到Pod存储约束的总值。如果所有容器的本地临时性存储用量总和加上Pod的emptyDir卷的用量超出Pod存储约束值，kubelet也会将该Pod标记为逐出候选。注意：如果kubelet没有度量本地临时性存储的用量，即使Pod的本地存储用量超出其约束值也不会被逐出。不过，如果用于可写入容器镜像层、节点层面日志或者emptyDir卷的文件系统中可用空间太少，节点会为自身设置本地存储不足的污点标签。这一污点会触发对那些无法容忍该污点的Pods的逐出操作。关于临时性本地存储的配置信息，请参考这里kubelet支持使用不同方式来度量Pod的存储用量：周期性扫描文件系统项目配额kubelet按预定周期执行扫描操作，检查emptyDir卷、容器日志目录以及可写入容器镜像层。这一扫描会度量存储空间用量。说明：在这种模式下，kubelet并不检查已删除文件所对应的、仍处于打开状态的文件描述符。如果你（或者容器）在emptyDir卷中创建了一个文件，写入一些内容之后再次打开该文件并执行了删除操作，所删除文件对应的inode仍然存在，直到你关闭该文件为止。kubelet不会将该文件所占用的空间视为已使用空间。为容器管理资源当你定义Pod时可以选择性地为每个容器设定所需要的资源数量。最常见的可设定资源是CPU和内存（RAM）大小；此外还有其他类型的资源。当你为Pod中的Container指定了资源请求时，调度器就利用该信息决定将Pod调度到哪个节点上。当你还为Container指定了资源约束时，kubelet就可以确保运行的容器不会使用超出所设约束的资源。kubelet还会为容器预留所请求数量的系统资源，供其使用。请求和约束如果Pod运行所在的节点具有足够的可用资源，容器可能（且可以）使用超出对应资源request属性所设置的资源量。不过，容器不可以使用超出其资源limit属性所设置的资源量。例如，如果你将容器的memory的请求量设置为256MiB，而该容器所处的Pod被调度到一个具有8GiB内存的节点上，并且该节点上没有其他Pods运行，那么该容器就可以尝试使用更多的内存。如果你将某容器的memory约束设置为4GiB，kubelet（和容器运行时）就会确保该约束生效。容器运行时会禁止容器使用超出所设置资源约束的资源。例如：当容器中进程尝试使用超出所允许内存量的资源时，系统内核会将尝试申请内存的进程终止，并引发内存不足（OOM）错误。约束值可以以被动方式来实现（系统会在发现违例时进行干预），或者通过强制生效的方式实现（系统会避免容器用量超出约束值）。不同的容器运行时采用不同方式来实现相同的限制。说明：如果某Container设置了自己的内存限制但未设置内存请求，Kubernetes自动为其设置与内存限制相匹配的请求值。类似的，如果某Container设置了CPU限制值但未设置CPU请求值，则Kubernetes自动为其设置CPU请求并使之与CPU限制值匹配。资源类型CPU和内存都是资源类型。每种资源类型具有其基本单位。CPU表达的是计算处理能力，其单位是KubernetesCPUs。内存的单位是字节。如果你使用的是Kubernetesv1.14或更高版本，则可以指定巨页（HugePage）资源。巨页是Linux特有的功能，节点内核在其中分配的内存块比默认页大小大得多。例如，在默认页面大小为4KiB的系统上，你可以指定约束hugepages-2Mi:80Mi。如果容器尝试分配40个2MiB大小的巨页（总共80MiB），则分配请求会失败。说明：你不能过量使用hugepages-*资源。这与memory和cpu资源不同。CPU和内存统称为计算资源，或简称为资源。计算资源的数量是可测量的，可以被请求、被分配、被消耗。它们与API资源不同。API资源（如Pod和Service）是可通过KubernetesAPI服务器读取和修改的对象。Pod和容器的资源请求和约束Pod中的每个容器都可以指定以下的一个或者多个值：spec.containers[].resources.limits.cpuspec.containers[].resources.limits.memoryspec.containers[].resources.limits.hugepages-<size>spec.containers[].resources.requests.cpuspec.containers[].resources.requests.memoryspec.containers[].resources.requests.hugepages-<size>尽管请求和限制值只能在单个容器上指定，我们仍可方便地计算出Pod的资源请求和约束。Pod对特定资源类型的请求/约束值是Pod中各容器对该类型资源的请求/约束值的总和。Kubernetes中的资源单位CPU的含义CPU资源的约束和请求以CPU为单位。Kubernetes中的一个CPU等于云平台上的1个vCPU/核和裸机Intel处理器上的1个超线程。你也可以表达带小数CPU的请求。spec.containers[].resources.requests.cpu为0.5的Container肯定能够获得请求1CPU的容器的一半CPU资源。表达式0.1等价于表达式100m，可以看作“100millicpu”。有些人说成是“一百毫cpu”，其实说的是同样的事情。具有小数点（如0.1）的请求由API转换为100m；最大精度是1m。因此，或许你应该优先考虑使用100m的形式。CPU总是按绝对数量来请求的，不可以使用相对数量；0.1的CPU在单核、双核、48核的机器上的意义是一样的。内存的含义内存的约束和请求以字节为单位。你可以使用以下后缀之一以一般整数或定点数字形式来表示内存：E、P、T、G、M、k。你也可以使用对应的2的幂数：Ei、Pi、Ti、Gi、Mi、Ki。例如，以下表达式所代表的是大致相同的值：128974848、129e6、129M、123Mi下面是个例子。以下Pod有两个Container。每个Container的请求为0.25cpu和64MiB（226字节）内存，每个容器的资源约束为0.5cpu和128MiB内存。你可以认为该Pod的资源请求为0.5cpu和128MiB内存，资源限制为1cpu和256MiB内存。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4env:-name:MYSQL_ROOT_PASSWORDvalue:passwordresources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m带资源请求的Pod如何调度当你创建一个Pod时，Kubernetes调度程序将为Pod选择一个节点。每个节点对每种资源类型都有一个容量上限：可为Pod提供的CPU和内存量。调度程序确保对于每种资源类型，所调度的容器的资源请求的总和小于节点的容量。请注意，尽管节点上的实际内存或CPU资源使用量非常低，如果容量检查失败，调度程序仍会拒绝在该节点上放置Pod。当稍后节点上资源用量增加，例如到达请求率的每日峰值区间时，节点上也不会出现资源不足的问题。带资源约束的Pod如何运行当kubelet启动Pod中的Container时，它会将CPU和内存约束信息传递给容器运行时。当使用Docker时：spec.containers[].resources.requests.cpu先被转换为可能是小数的基础值，再乘以1024。这个数值和2的较大者用作dockerrun命令中的--cpu-shares标志的值。spec.containers[].resources.limits.cpu先被转换为millicore值，再乘以100。其结果就是每100毫秒内容器可以使用的CPU时间总量，单位为微秒。在此期间（100ms），容器所使用的CPU时间不可以超过它被分配的时间。说明：默认的配额（Quota）周期为100毫秒。CPU配额的最小精度为1毫秒。spec.containers[].resources.limits.memory被转换为整数值，作为dockerrun命令中的--memory参数值。如果Container超过其内存限制，则可能会被终止。如果容器可重新启动，则与所有其他类型的运行时失效一样，kubelet将重新启动容器。如果一个Container内存用量超过其内存请求值，那么当节点内存不足时，容器所处的Pod可能被逐出。每个Container可能被允许也可能不被允许使用超过其CPU约束的处理时间。但是，容器不会由于CPU使用率过高而被杀死。要确定Container是否会由于资源约束而无法调度或被杀死，请参阅疑难解答部分。监控计算和内存资源用量Pod的资源使用情况是作为Pod状态的一部分来报告的。如果为集群配置了可选的监控工具，则可以直接从指标API或者监控工具获得Pod的资源使用情况。本地临时存储FEATURESTATE:Kubernetesv1.10[beta]节点通常还可以具有本地的临时性存储，由本地挂接的可写入设备或者有时也用RAM来提供支持。“临时（Ephemeral）”意味着对所存储的数据不提供长期可用性的保证。Pods通常可以使用临时性本地存储来实现缓冲区、保存日志等功能。kubelet可以为使用本地临时存储的Pods提供这种存储空间，允许后者使用emptyDir类型的卷将其挂载到容器中。kubelet也使用此类存储来保存节点层面的容器日志，容器镜像文件、以及运行中容器的可写入层。注意：如果节点失效，存储在临时性存储中的数据会丢失。你的应用不能对本地临时性存储的性能SLA（例如磁盘IOPS）作任何假定。作为一种beta阶段功能特性，Kubernetes允许你跟踪、预留和限制Pod可消耗的临时性本地存储数量。本地临时性存储的配置Kubernetes有两种方式支持节点上配置本地临时性存储：单一文件系统双文件系统采用这种配置时，你会把所有类型的临时性本地数据（包括emptyDir卷、可写入容器层、容器镜像、日志等）放到同一个文件系统中。作为最有效的kubelet配置方式，这意味着该文件系统是专门提供给Kubernetes（kubelet）来保存数据的。kubelet也会生成节点层面的容器日志，并按临时性本地存储的方式对待之。kubelet会将日志写入到所配置的日志目录（默认为/var/log）下的文件中；还会针对其他本地存储的数据使用同一个基础目录（默认为/var/lib/kubelet）。通常，/var/lib/kubelet和/var/log都是在系统的根文件系统中。kubelet的设计也考虑到这一点。你的集群节点当然可以包含其他的、并非用于Kubernetes的很多文件系统。kubelet能够度量其本地存储的用量。实现度量机制的前提是：LocalStorageCapacityIsolation特性门控被启用（默认状态），并且你已经对节点进行了配置，使之使用所支持的本地临时性储存配置方式之一如果你的节点配置不同于以上预期，kubelet就无法对临时性本地存储的资源约束实施限制。说明：kubelet会将tmpfsemptyDir卷的用量当作容器内存用量，而不是本地临时性存储来统计。为本地临时性存储设置请求和约束值你可以使用ephemeral-storage来管理本地临时性存储。Pod中的每个Container可以设置以下属性：spec.containers[].resources.limits.ephemeral-storagespec.containers[].resources.requests.ephemeral-storageephemeral-storage的请求和约束值是按字节计量的。你可以使用一般整数或者定点数字加上下面的后缀来表达存储量：E、P、T、G、M、K。你也可以使用对应的2的幂级数来表达：Ei、Pi、Ti、Gi、Mi、Ki。例如，下面的表达式所表达的大致是同一个值：128974848,129e6,129M,123Mi在下面的例子中，Pod包含两个Container。每个Container请求2GiB大小的本地临时性存储。每个Container都设置了4GiB作为其本地临时性存储的约束值。因此，整个Pod的本地临时性存储请求是4GiB，且其本地临时性存储的约束为8GiB。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmp-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmpvolumes:-name:ephemeralemptyDir:{}带临时性存储的Pods的调度行为当你创建一个Pod时，Kubernetes调度器会为Pod选择一个节点来运行之。每个节点都有一个本地临时性存储的上限，是其可提供给Pods使用的总量。欲了解更多信息，可参考节点可分配资源节。调度器会确保所调度的Containers的资源请求总和不会超出节点的资源容量。临时性存储消耗的管理如果kubelet将本地临时性存储作为资源来管理，则kubelet会度量以下各处的存储用量：emptyDir卷，除了tmpfsemptyDir卷保存节点层面日志的目录可写入的容器镜像层如果某Pod的临时存储用量超出了你所允许的范围，kubelet会向其发出逐出（eviction）信号，触发该Pod被逐出所在节点。就容器层面的隔离而言，如果某容器的可写入镜像层和日志用量超出其存储约束，kubelet也会将所在的Pod标记为逐出候选。就Pod层面的隔离而言，kubelet会将Pod中所有容器的约束值相加，得到Pod存储约束的总值。如果所有容器的本地临时性存储用量总和加上Pod的emptyDir卷的用量超出Pod存储约束值，kubelet也会将该Pod标记为逐出候选。注意：如果kubelet没有度量本地临时性存储的用量，即使Pod的本地存储用量超出其约束值也不会被逐出。不过，如果用于可写入容器镜像层、节点层面日志或者emptyDir卷的文件系统中可用空间太少，节点会为自身设置本地存储不足的污点标签。这一污点会触发对那些无法容忍该污点的Pods的逐出操作。关于临时性本地存储的配置信息，请参考这里kubelet支持使用不同方式来度量Pod的存储用量：周期性扫描文件系统项目配额kubelet按预定周期执行扫描操作，检查emptyDir卷、容器日志目录以及可写入容器镜像层。这一扫描会度量存储空间用量。说明：在这种模式下，kubelet并不检查已删除文件所对应的、仍处于打开状态的文件描述符。如果你（或者容器）在emptyDir卷中创建了一个文件，写入一些内容之后再次打开该文件并执行了删除操作，所删除文件对应的inode仍然存在，直到你关闭该文件为止。kubelet不会将该文件所占用的空间视为已使用空间。为容器管理资源当你定义Pod时可以选择性地为每个容器设定所需要的资源数量。最常见的可设定资源是CPU和内存（RAM）大小；此外还有其他类型的资源。当你为Pod中的Container指定了资源请求时，调度器就利用该信息决定将Pod调度到哪个节点上。当你还为Container指定了资源约束时，kubelet就可以确保运行的容器不会使用超出所设约束的资源。kubelet还会为容器预留所请求数量的系统资源，供其使用。请求和约束如果Pod运行所在的节点具有足够的可用资源，容器可能（且可以）使用超出对应资源request属性所设置的资源量。不过，容器不可以使用超出其资源limit属性所设置的资源量。例如，如果你将容器的memory的请求量设置为256MiB，而该容器所处的Pod被调度到一个具有8GiB内存的节点上，并且该节点上没有其他Pods运行，那么该容器就可以尝试使用更多的内存。如果你将某容器的memory约束设置为4GiB，kubelet（和容器运行时）就会确保该约束生效。容器运行时会禁止容器使用超出所设置资源约束的资源。例如：当容器中进程尝试使用超出所允许内存量的资源时，系统内核会将尝试申请内存的进程终止，并引发内存不足（OOM）错误。约束值可以以被动方式来实现（系统会在发现违例时进行干预），或者通过强制生效的方式实现（系统会避免容器用量超出约束值）。不同的容器运行时采用不同方式来实现相同的限制。说明：如果某Container设置了自己的内存限制但未设置内存请求，Kubernetes自动为其设置与内存限制相匹配的请求值。类似的，如果某Container设置了CPU限制值但未设置CPU请求值，则Kubernetes自动为其设置CPU请求并使之与CPU限制值匹配。资源类型CPU和内存都是资源类型。每种资源类型具有其基本单位。CPU表达的是计算处理能力，其单位是KubernetesCPUs。内存的单位是字节。如果你使用的是Kubernetesv1.14或更高版本，则可以指定巨页（HugePage）资源。巨页是Linux特有的功能，节点内核在其中分配的内存块比默认页大小大得多。例如，在默认页面大小为4KiB的系统上，你可以指定约束hugepages-2Mi:80Mi。如果容器尝试分配40个2MiB大小的巨页（总共80MiB），则分配请求会失败。说明：你不能过量使用hugepages-*资源。这与memory和cpu资源不同。CPU和内存统称为计算资源，或简称为资源。计算资源的数量是可测量的，可以被请求、被分配、被消耗。它们与API资源不同。API资源（如Pod和Service）是可通过KubernetesAPI服务器读取和修改的对象。Pod和容器的资源请求和约束Pod中的每个容器都可以指定以下的一个或者多个值：spec.containers[].resources.limits.cpuspec.containers[].resources.limits.memoryspec.containers[].resources.limits.hugepages-<size>spec.containers[].resources.requests.cpuspec.containers[].resources.requests.memoryspec.containers[].resources.requests.hugepages-<size>尽管请求和限制值只能在单个容器上指定，我们仍可方便地计算出Pod的资源请求和约束。Pod对特定资源类型的请求/约束值是Pod中各容器对该类型资源的请求/约束值的总和。Kubernetes中的资源单位CPU的含义CPU资源的约束和请求以CPU为单位。Kubernetes中的一个CPU等于云平台上的1个vCPU/核和裸机Intel处理器上的1个超线程。你也可以表达带小数CPU的请求。spec.containers[].resources.requests.cpu为0.5的Container肯定能够获得请求1CPU的容器的一半CPU资源。表达式0.1等价于表达式100m，可以看作“100millicpu”。有些人说成是“一百毫cpu”，其实说的是同样的事情。具有小数点（如0.1）的请求由API转换为100m；最大精度是1m。因此，或许你应该优先考虑使用100m的形式。CPU总是按绝对数量来请求的，不可以使用相对数量；0.1的CPU在单核、双核、48核的机器上的意义是一样的。内存的含义内存的约束和请求以字节为单位。你可以使用以下后缀之一以一般整数或定点数字形式来表示内存：E、P、T、G、M、k。你也可以使用对应的2的幂数：Ei、Pi、Ti、Gi、Mi、Ki。例如，以下表达式所代表的是大致相同的值：128974848、129e6、129M、123Mi下面是个例子。以下Pod有两个Container。每个Container的请求为0.25cpu和64MiB（226字节）内存，每个容器的资源约束为0.5cpu和128MiB内存。你可以认为该Pod的资源请求为0.5cpu和128MiB内存，资源限制为1cpu和256MiB内存。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4env:-name:MYSQL_ROOT_PASSWORDvalue:passwordresources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m带资源请求的Pod如何调度当你创建一个Pod时，Kubernetes调度程序将为Pod选择一个节点。每个节点对每种资源类型都有一个容量上限：可为Pod提供的CPU和内存量。调度程序确保对于每种资源类型，所调度的容器的资源请求的总和小于节点的容量。请注意，尽管节点上的实际内存或CPU资源使用量非常低，如果容量检查失败，调度程序仍会拒绝在该节点上放置Pod。当稍后节点上资源用量增加，例如到达请求率的每日峰值区间时，节点上也不会出现资源不足的问题。带资源约束的Pod如何运行当kubelet启动Pod中的Container时，它会将CPU和内存约束信息传递给容器运行时。当使用Docker时：spec.containers[].resources.requests.cpu先被转换为可能是小数的基础值，再乘以1024。这个数值和2的较大者用作dockerrun命令中的--cpu-shares标志的值。spec.containers[].resources.limits.cpu先被转换为millicore值，再乘以100。其结果就是每100毫秒内容器可以使用的CPU时间总量，单位为微秒。在此期间（100ms），容器所使用的CPU时间不可以超过它被分配的时间。说明：默认的配额（Quota）周期为100毫秒。CPU配额的最小精度为1毫秒。spec.containers[].resources.limits.memory被转换为整数值，作为dockerrun命令中的--memory参数值。如果Container超过其内存限制，则可能会被终止。如果容器可重新启动，则与所有其他类型的运行时失效一样，kubelet将重新启动容器。如果一个Container内存用量超过其内存请求值，那么当节点内存不足时，容器所处的Pod可能被逐出。每个Container可能被允许也可能不被允许使用超过其CPU约束的处理时间。但是，容器不会由于CPU使用率过高而被杀死。要确定Container是否会由于资源约束而无法调度或被杀死，请参阅疑难解答部分。监控计算和内存资源用量Pod的资源使用情况是作为Pod状态的一部分来报告的。如果为集群配置了可选的监控工具，则可以直接从指标API或者监控工具获得Pod的资源使用情况。本地临时存储FEATURESTATE:Kubernetesv1.10[beta]节点通常还可以具有本地的临时性存储，由本地挂接的可写入设备或者有时也用RAM来提供支持。“临时（Ephemeral）”意味着对所存储的数据不提供长期可用性的保证。Pods通常可以使用临时性本地存储来实现缓冲区、保存日志等功能。kubelet可以为使用本地临时存储的Pods提供这种存储空间，允许后者使用emptyDir类型的卷将其挂载到容器中。kubelet也使用此类存储来保存节点层面的容器日志，容器镜像文件、以及运行中容器的可写入层。注意：如果节点失效，存储在临时性存储中的数据会丢失。你的应用不能对本地临时性存储的性能SLA（例如磁盘IOPS）作任何假定。作为一种beta阶段功能特性，Kubernetes允许你跟踪、预留和限制Pod可消耗的临时性本地存储数量。本地临时性存储的配置Kubernetes有两种方式支持节点上配置本地临时性存储：单一文件系统双文件系统采用这种配置时，你会把所有类型的临时性本地数据（包括emptyDir卷、可写入容器层、容器镜像、日志等）放到同一个文件系统中。作为最有效的kubelet配置方式，这意味着该文件系统是专门提供给Kubernetes（kubelet）来保存数据的。kubelet也会生成节点层面的容器日志，并按临时性本地存储的方式对待之。kubelet会将日志写入到所配置的日志目录（默认为/var/log）下的文件中；还会针对其他本地存储的数据使用同一个基础目录（默认为/var/lib/kubelet）。通常，/var/lib/kubelet和/var/log都是在系统的根文件系统中。kubelet的设计也考虑到这一点。你的集群节点当然可以包含其他的、并非用于Kubernetes的很多文件系统。kubelet能够度量其本地存储的用量。实现度量机制的前提是：LocalStorageCapacityIsolation特性门控被启用（默认状态），并且你已经对节点进行了配置，使之使用所支持的本地临时性储存配置方式之一如果你的节点配置不同于以上预期，kubelet就无法对临时性本地存储的资源约束实施限制。说明：kubelet会将tmpfsemptyDir卷的用量当作容器内存用量，而不是本地临时性存储来统计。为本地临时性存储设置请求和约束值你可以使用ephemeral-storage来管理本地临时性存储。Pod中的每个Container可以设置以下属性：spec.containers[].resources.limits.ephemeral-storagespec.containers[].resources.requests.ephemeral-storageephemeral-storage的请求和约束值是按字节计量的。你可以使用一般整数或者定点数字加上下面的后缀来表达存储量：E、P、T、G、M、K。你也可以使用对应的2的幂级数来表达：Ei、Pi、Ti、Gi、Mi、Ki。例如，下面的表达式所表达的大致是同一个值：128974848,129e6,129M,123Mi在下面的例子中，Pod包含两个Container。每个Container请求2GiB大小的本地临时性存储。每个Container都设置了4GiB作为其本地临时性存储的约束值。因此，整个Pod的本地临时性存储请求是4GiB，且其本地临时性存储的约束为8GiB。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmp-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmpvolumes:-name:ephemeralemptyDir:{}带临时性存储的Pods的调度行为当你创建一个Pod时，Kubernetes调度器会为Pod选择一个节点来运行之。每个节点都有一个本地临时性存储的上限，是其可提供给Pods使用的总量。欲了解更多信息，可参考节点可分配资源节。调度器会确保所调度的Containers的资源请求总和不会超出节点的资源容量。临时性存储消耗的管理如果kubelet将本地临时性存储作为资源来管理，则kubelet会度量以下各处的存储用量：emptyDir卷，除了tmpfsemptyDir卷保存节点层面日志的目录可写入的容器镜像层如果某Pod的临时存储用量超出了你所允许的范围，kubelet会向其发出逐出（eviction）信号，触发该Pod被逐出所在节点。就容器层面的隔离而言，如果某容器的可写入镜像层和日志用量超出其存储约束，kubelet也会将所在的Pod标记为逐出候选。就Pod层面的隔离而言，kubelet会将Pod中所有容器的约束值相加，得到Pod存储约束的总值。如果所有容器的本地临时性存储用量总和加上Pod的emptyDir卷的用量超出Pod存储约束值，kubelet也会将该Pod标记为逐出候选。注意：如果kubelet没有度量本地临时性存储的用量，即使Pod的本地存储用量超出其约束值也不会被逐出。不过，如果用于可写入容器镜像层、节点层面日志或者emptyDir卷的文件系统中可用空间太少，节点会为自身设置本地存储不足的污点标签。这一污点会触发对那些无法容忍该污点的Pods的逐出操作。关于临时性本地存储的配置信息，请参考这里kubelet支持使用不同方式来度量Pod的存储用量：周期性扫描文件系统项目配额kubelet按预定周期执行扫描操作，检查emptyDir卷、容器日志目录以及可写入容器镜像层。这一扫描会度量存储空间用量。说明：在这种模式下，kubelet并不检查已删除文件所对应的、仍处于打开状态的文件描述符。如果你（或者容器）在emptyDir卷中创建了一个文件，写入一些内容之后再次打开该文件并执行了删除操作，所删除文件对应的inode仍然存在，直到你关闭该文件为止。kubelet不会将该文件所占用的空间视为已使用空间。为容器管理资源当你定义Pod时可以选择性地为每个容器设定所需要的资源数量。最常见的可设定资源是CPU和内存（RAM）大小；此外还有其他类型的资源。当你为Pod中的Container指定了资源请求时，调度器就利用该信息决定将Pod调度到哪个节点上。当你还为Container指定了资源约束时，kubelet就可以确保运行的容器不会使用超出所设约束的资源。kubelet还会为容器预留所请求数量的系统资源，供其使用。请求和约束如果Pod运行所在的节点具有足够的可用资源，容器可能（且可以）使用超出对应资源request属性所设置的资源量。不过，容器不可以使用超出其资源limit属性所设置的资源量。例如，如果你将容器的memory的请求量设置为256MiB，而该容器所处的Pod被调度到一个具有8GiB内存的节点上，并且该节点上没有其他Pods运行，那么该容器就可以尝试使用更多的内存。如果你将某容器的memory约束设置为4GiB，kubelet（和容器运行时）就会确保该约束生效。容器运行时会禁止容器使用超出所设置资源约束的资源。例如：当容器中进程尝试使用超出所允许内存量的资源时，系统内核会将尝试申请内存的进程终止，并引发内存不足（OOM）错误。约束值可以以被动方式来实现（系统会在发现违例时进行干预），或者通过强制生效的方式实现（系统会避免容器用量超出约束值）。不同的容器运行时采用不同方式来实现相同的限制。说明：如果某Container设置了自己的内存限制但未设置内存请求，Kubernetes自动为其设置与内存限制相匹配的请求值。类似的，如果某Container设置了CPU限制值但未设置CPU请求值，则Kubernetes自动为其设置CPU请求并使之与CPU限制值匹配。资源类型CPU和内存都是资源类型。每种资源类型具有其基本单位。CPU表达的是计算处理能力，其单位是KubernetesCPUs。内存的单位是字节。如果你使用的是Kubernetesv1.14或更高版本，则可以指定巨页（HugePage）资源。巨页是Linux特有的功能，节点内核在其中分配的内存块比默认页大小大得多。例如，在默认页面大小为4KiB的系统上，你可以指定约束hugepages-2Mi:80Mi。如果容器尝试分配40个2MiB大小的巨页（总共80MiB），则分配请求会失败。说明：你不能过量使用hugepages-*资源。这与memory和cpu资源不同。CPU和内存统称为计算资源，或简称为资源。计算资源的数量是可测量的，可以被请求、被分配、被消耗。它们与API资源不同。API资源（如Pod和Service）是可通过KubernetesAPI服务器读取和修改的对象。Pod和容器的资源请求和约束Pod中的每个容器都可以指定以下的一个或者多个值：spec.containers[].resources.limits.cpuspec.containers[].resources.limits.memoryspec.containers[].resources.limits.hugepages-<size>spec.containers[].resources.requests.cpuspec.containers[].resources.requests.memoryspec.containers[].resources.requests.hugepages-<size>尽管请求和限制值只能在单个容器上指定，我们仍可方便地计算出Pod的资源请求和约束。Pod对特定资源类型的请求/约束值是Pod中各容器对该类型资源的请求/约束值的总和。Kubernetes中的资源单位CPU的含义CPU资源的约束和请求以CPU为单位。Kubernetes中的一个CPU等于云平台上的1个vCPU/核和裸机Intel处理器上的1个超线程。你也可以表达带小数CPU的请求。spec.containers[].resources.requests.cpu为0.5的Container肯定能够获得请求1CPU的容器的一半CPU资源。表达式0.1等价于表达式100m，可以看作“100millicpu”。有些人说成是“一百毫cpu”，其实说的是同样的事情。具有小数点（如0.1）的请求由API转换为100m；最大精度是1m。因此，或许你应该优先考虑使用100m的形式。CPU总是按绝对数量来请求的，不可以使用相对数量；0.1的CPU在单核、双核、48核的机器上的意义是一样的。内存的含义内存的约束和请求以字节为单位。你可以使用以下后缀之一以一般整数或定点数字形式来表示内存：E、P、T、G、M、k。你也可以使用对应的2的幂数：Ei、Pi、Ti、Gi、Mi、Ki。例如，以下表达式所代表的是大致相同的值：128974848、129e6、129M、123Mi下面是个例子。以下Pod有两个Container。每个Container的请求为0.25cpu和64MiB（226字节）内存，每个容器的资源约束为0.5cpu和128MiB内存。你可以认为该Pod的资源请求为0.5cpu和128MiB内存，资源限制为1cpu和256MiB内存。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4env:-name:MYSQL_ROOT_PASSWORDvalue:passwordresources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m带资源请求的Pod如何调度当你创建一个Pod时，Kubernetes调度程序将为Pod选择一个节点。每个节点对每种资源类型都有一个容量上限：可为Pod提供的CPU和内存量。调度程序确保对于每种资源类型，所调度的容器的资源请求的总和小于节点的容量。请注意，尽管节点上的实际内存或CPU资源使用量非常低，如果容量检查失败，调度程序仍会拒绝在该节点上放置Pod。当稍后节点上资源用量增加，例如到达请求率的每日峰值区间时，节点上也不会出现资源不足的问题。带资源约束的Pod如何运行当kubelet启动Pod中的Container时，它会将CPU和内存约束信息传递给容器运行时。当使用Docker时：spec.containers[].resources.requests.cpu先被转换为可能是小数的基础值，再乘以1024。这个数值和2的较大者用作dockerrun命令中的--cpu-shares标志的值。spec.containers[].resources.limits.cpu先被转换为millicore值，再乘以100。其结果就是每100毫秒内容器可以使用的CPU时间总量，单位为微秒。在此期间（100ms），容器所使用的CPU时间不可以超过它被分配的时间。说明：默认的配额（Quota）周期为100毫秒。CPU配额的最小精度为1毫秒。spec.containers[].resources.limits.memory被转换为整数值，作为dockerrun命令中的--memory参数值。如果Container超过其内存限制，则可能会被终止。如果容器可重新启动，则与所有其他类型的运行时失效一样，kubelet将重新启动容器。如果一个Container内存用量超过其内存请求值，那么当节点内存不足时，容器所处的Pod可能被逐出。每个Container可能被允许也可能不被允许使用超过其CPU约束的处理时间。但是，容器不会由于CPU使用率过高而被杀死。要确定Container是否会由于资源约束而无法调度或被杀死，请参阅疑难解答部分。监控计算和内存资源用量Pod的资源使用情况是作为Pod状态的一部分来报告的。如果为集群配置了可选的监控工具，则可以直接从指标API或者监控工具获得Pod的资源使用情况。本地临时存储FEATURESTATE:Kubernetesv1.10[beta]节点通常还可以具有本地的临时性存储，由本地挂接的可写入设备或者有时也用RAM来提供支持。“临时（Ephemeral）”意味着对所存储的数据不提供长期可用性的保证。Pods通常可以使用临时性本地存储来实现缓冲区、保存日志等功能。kubelet可以为使用本地临时存储的Pods提供这种存储空间，允许后者使用emptyDir类型的卷将其挂载到容器中。kubelet也使用此类存储来保存节点层面的容器日志，容器镜像文件、以及运行中容器的可写入层。注意：如果节点失效，存储在临时性存储中的数据会丢失。你的应用不能对本地临时性存储的性能SLA（例如磁盘IOPS）作任何假定。作为一种beta阶段功能特性，Kubernetes允许你跟踪、预留和限制Pod可消耗的临时性本地存储数量。本地临时性存储的配置Kubernetes有两种方式支持节点上配置本地临时性存储：单一文件系统双文件系统采用这种配置时，你会把所有类型的临时性本地数据（包括emptyDir卷、可写入容器层、容器镜像、日志等）放到同一个文件系统中。作为最有效的kubelet配置方式，这意味着该文件系统是专门提供给Kubernetes（kubelet）来保存数据的。kubelet也会生成节点层面的容器日志，并按临时性本地存储的方式对待之。kubelet会将日志写入到所配置的日志目录（默认为/var/log）下的文件中；还会针对其他本地存储的数据使用同一个基础目录（默认为/var/lib/kubelet）。通常，/var/lib/kubelet和/var/log都是在系统的根文件系统中。kubelet的设计也考虑到这一点。你的集群节点当然可以包含其他的、并非用于Kubernetes的很多文件系统。kubelet能够度量其本地存储的用量。实现度量机制的前提是：LocalStorageCapacityIsolation特性门控被启用（默认状态），并且你已经对节点进行了配置，使之使用所支持的本地临时性储存配置方式之一如果你的节点配置不同于以上预期，kubelet就无法对临时性本地存储的资源约束实施限制。说明：kubelet会将tmpfsemptyDir卷的用量当作容器内存用量，而不是本地临时性存储来统计。为本地临时性存储设置请求和约束值你可以使用ephemeral-storage来管理本地临时性存储。Pod中的每个Container可以设置以下属性：spec.containers[].resources.limits.ephemeral-storagespec.containers[].resources.requests.ephemeral-storageephemeral-storage的请求和约束值是按字节计量的。你可以使用一般整数或者定点数字加上下面的后缀来表达存储量：E、P、T、G、M、K。你也可以使用对应的2的幂级数来表达：Ei、Pi、Ti、Gi、Mi、Ki。例如，下面的表达式所表达的大致是同一个值：128974848,129e6,129M,123Mi在下面的例子中，Pod包含两个Container。每个Container请求2GiB大小的本地临时性存储。每个Container都设置了4GiB作为其本地临时性存储的约束值。因此，整个Pod的本地临时性存储请求是4GiB，且其本地临时性存储的约束为8GiB。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmp-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmpvolumes:-name:ephemeralemptyDir:{}带临时性存储的Pods的调度行为当你创建一个Pod时，Kubernetes调度器会为Pod选择一个节点来运行之。每个节点都有一个本地临时性存储的上限，是其可提供给Pods使用的总量。欲了解更多信息，可参考节点可分配资源节。调度器会确保所调度的Containers的资源请求总和不会超出节点的资源容量。临时性存储消耗的管理如果kubelet将本地临时性存储作为资源来管理，则kubelet会度量以下各处的存储用量：emptyDir卷，除了tmpfsemptyDir卷保存节点层面日志的目录可写入的容器镜像层如果某Pod的临时存储用量超出了你所允许的范围，kubelet会向其发出逐出（eviction）信号，触发该Pod被逐出所在节点。就容器层面的隔离而言，如果某容器的可写入镜像层和日志用量超出其存储约束，kubelet也会将所在的Pod标记为逐出候选。就Pod层面的隔离而言，kubelet会将Pod中所有容器的约束值相加，得到Pod存储约束的总值。如果所有容器的本地临时性存储用量总和加上Pod的emptyDir卷的用量超出Pod存储约束值，kubelet也会将该Pod标记为逐出候选。注意：如果kubelet没有度量本地临时性存储的用量，即使Pod的本地存储用量超出其约束值也不会被逐出。不过，如果用于可写入容器镜像层、节点层面日志或者emptyDir卷的文件系统中可用空间太少，节点会为自身设置本地存储不足的污点标签。这一污点会触发对那些无法容忍该污点的Pods的逐出操作。关于临时性本地存储的配置信息，请参考这里kubelet支持使用不同方式来度量Pod的存储用量：周期性扫描文件系统项目配额kubelet按预定周期执行扫描操作，检查emptyDir卷、容器日志目录以及可写入容器镜像层。这一扫描会度量存储空间用量。说明：在这种模式下，kubelet并不检查已删除文件所对应的、仍处于打开状态的文件描述符。如果你（或者容器）在emptyDir卷中创建了一个文件，写入一些内容之后再次打开该文件并执行了删除操作，所删除文件对应的inode仍然存在，直到你关闭该文件为止。kubelet不会将该文件所占用的空间视为已使用空间。为容器管理资源当你定义Pod时可以选择性地为每个容器设定所需要的资源数量。最常见的可设定资源是CPU和内存（RAM）大小；此外还有其他类型的资源。当你为Pod中的Container指定了资源请求时，调度器就利用该信息决定将Pod调度到哪个节点上。当你还为Container指定了资源约束时，kubelet就可以确保运行的容器不会使用超出所设约束的资源。kubelet还会为容器预留所请求数量的系统资源，供其使用。请求和约束如果Pod运行所在的节点具有足够的可用资源，容器可能（且可以）使用超出对应资源request属性所设置的资源量。不过，容器不可以使用超出其资源limit属性所设置的资源量。例如，如果你将容器的memory的请求量设置为256MiB，而该容器所处的Pod被调度到一个具有8GiB内存的节点上，并且该节点上没有其他Pods运行，那么该容器就可以尝试使用更多的内存。如果你将某容器的memory约束设置为4GiB，kubelet（和容器运行时）就会确保该约束生效。容器运行时会禁止容器使用超出所设置资源约束的资源。例如：当容器中进程尝试使用超出所允许内存量的资源时，系统内核会将尝试申请内存的进程终止，并引发内存不足（OOM）错误。约束值可以以被动方式来实现（系统会在发现违例时进行干预），或者通过强制生效的方式实现（系统会避免容器用量超出约束值）。不同的容器运行时采用不同方式来实现相同的限制。说明：如果某Container设置了自己的内存限制但未设置内存请求，Kubernetes自动为其设置与内存限制相匹配的请求值。类似的，如果某Container设置了CPU限制值但未设置CPU请求值，则Kubernetes自动为其设置CPU请求并使之与CPU限制值匹配。资源类型CPU和内存都是资源类型。每种资源类型具有其基本单位。CPU表达的是计算处理能力，其单位是KubernetesCPUs。内存的单位是字节。如果你使用的是Kubernetesv1.14或更高版本，则可以指定巨页（HugePage）资源。巨页是Linux特有的功能，节点内核在其中分配的内存块比默认页大小大得多。例如，在默认页面大小为4KiB的系统上，你可以指定约束hugepages-2Mi:80Mi。如果容器尝试分配40个2MiB大小的巨页（总共80MiB），则分配请求会失败。说明：你不能过量使用hugepages-*资源。这与memory和cpu资源不同。CPU和内存统称为计算资源，或简称为资源。计算资源的数量是可测量的，可以被请求、被分配、被消耗。它们与API资源不同。API资源（如Pod和Service）是可通过KubernetesAPI服务器读取和修改的对象。Pod和容器的资源请求和约束Pod中的每个容器都可以指定以下的一个或者多个值：spec.containers[].resources.limits.cpuspec.containers[].resources.limits.memoryspec.containers[].resources.limits.hugepages-<size>spec.containers[].resources.requests.cpuspec.containers[].resources.requests.memoryspec.containers[].resources.requests.hugepages-<size>尽管请求和限制值只能在单个容器上指定，我们仍可方便地计算出Pod的资源请求和约束。Pod对特定资源类型的请求/约束值是Pod中各容器对该类型资源的请求/约束值的总和。Kubernetes中的资源单位CPU的含义CPU资源的约束和请求以CPU为单位。Kubernetes中的一个CPU等于云平台上的1个vCPU/核和裸机Intel处理器上的1个超线程。你也可以表达带小数CPU的请求。spec.containers[].resources.requests.cpu为0.5的Container肯定能够获得请求1CPU的容器的一半CPU资源。表达式0.1等价于表达式100m，可以看作“100millicpu”。有些人说成是“一百毫cpu”，其实说的是同样的事情。具有小数点（如0.1）的请求由API转换为100m；最大精度是1m。因此，或许你应该优先考虑使用100m的形式。CPU总是按绝对数量来请求的，不可以使用相对数量；0.1的CPU在单核、双核、48核的机器上的意义是一样的。内存的含义内存的约束和请求以字节为单位。你可以使用以下后缀之一以一般整数或定点数字形式来表示内存：E、P、T、G、M、k。你也可以使用对应的2的幂数：Ei、Pi、Ti、Gi、Mi、Ki。例如，以下表达式所代表的是大致相同的值：128974848、129e6、129M、123Mi下面是个例子。以下Pod有两个Container。每个Container的请求为0.25cpu和64MiB（226字节）内存，每个容器的资源约束为0.5cpu和128MiB内存。你可以认为该Pod的资源请求为0.5cpu和128MiB内存，资源限制为1cpu和256MiB内存。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4env:-name:MYSQL_ROOT_PASSWORDvalue:passwordresources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m带资源请求的Pod如何调度当你创建一个Pod时，Kubernetes调度程序将为Pod选择一个节点。每个节点对每种资源类型都有一个容量上限：可为Pod提供的CPU和内存量。调度程序确保对于每种资源类型，所调度的容器的资源请求的总和小于节点的容量。请注意，尽管节点上的实际内存或CPU资源使用量非常低，如果容量检查失败，调度程序仍会拒绝在该节点上放置Pod。当稍后节点上资源用量增加，例如到达请求率的每日峰值区间时，节点上也不会出现资源不足的问题。带资源约束的Pod如何运行当kubelet启动Pod中的Container时，它会将CPU和内存约束信息传递给容器运行时。当使用Docker时：spec.containers[].resources.requests.cpu先被转换为可能是小数的基础值，再乘以1024。这个数值和2的较大者用作dockerrun命令中的--cpu-shares标志的值。spec.containers[].resources.limits.cpu先被转换为millicore值，再乘以100。其结果就是每100毫秒内容器可以使用的CPU时间总量，单位为微秒。在此期间（100ms），容器所使用的CPU时间不可以超过它被分配的时间。说明：默认的配额（Quota）周期为100毫秒。CPU配额的最小精度为1毫秒。spec.containers[].resources.limits.memory被转换为整数值，作为dockerrun命令中的--memory参数值。如果Container超过其内存限制，则可能会被终止。如果容器可重新启动，则与所有其他类型的运行时失效一样，kubelet将重新启动容器。如果一个Container内存用量超过其内存请求值，那么当节点内存不足时，容器所处的Pod可能被逐出。每个Container可能被允许也可能不被允许使用超过其CPU约束的处理时间。但是，容器不会由于CPU使用率过高而被杀死。要确定Container是否会由于资源约束而无法调度或被杀死，请参阅疑难解答部分。监控计算和内存资源用量Pod的资源使用情况是作为Pod状态的一部分来报告的。如果为集群配置了可选的监控工具，则可以直接从指标API或者监控工具获得Pod的资源使用情况。本地临时存储FEATURESTATE:Kubernetesv1.10[beta]节点通常还可以具有本地的临时性存储，由本地挂接的可写入设备或者有时也用RAM来提供支持。“临时（Ephemeral）”意味着对所存储的数据不提供长期可用性的保证。Pods通常可以使用临时性本地存储来实现缓冲区、保存日志等功能。kubelet可以为使用本地临时存储的Pods提供这种存储空间，允许后者使用emptyDir类型的卷将其挂载到容器中。kubelet也使用此类存储来保存节点层面的容器日志，容器镜像文件、以及运行中容器的可写入层。注意：如果节点失效，存储在临时性存储中的数据会丢失。你的应用不能对本地临时性存储的性能SLA（例如磁盘IOPS）作任何假定。作为一种beta阶段功能特性，Kubernetes允许你跟踪、预留和限制Pod可消耗的临时性本地存储数量。本地临时性存储的配置Kubernetes有两种方式支持节点上配置本地临时性存储：单一文件系统双文件系统采用这种配置时，你会把所有类型的临时性本地数据（包括emptyDir卷、可写入容器层、容器镜像、日志等）放到同一个文件系统中。作为最有效的kubelet配置方式，这意味着该文件系统是专门提供给Kubernetes（kubelet）来保存数据的。kubelet也会生成节点层面的容器日志，并按临时性本地存储的方式对待之。kubelet会将日志写入到所配置的日志目录（默认为/var/log）下的文件中；还会针对其他本地存储的数据使用同一个基础目录（默认为/var/lib/kubelet）。通常，/var/lib/kubelet和/var/log都是在系统的根文件系统中。kubelet的设计也考虑到这一点。你的集群节点当然可以包含其他的、并非用于Kubernetes的很多文件系统。kubelet能够度量其本地存储的用量。实现度量机制的前提是：LocalStorageCapacityIsolation特性门控被启用（默认状态），并且你已经对节点进行了配置，使之使用所支持的本地临时性储存配置方式之一如果你的节点配置不同于以上预期，kubelet就无法对临时性本地存储的资源约束实施限制。说明：kubelet会将tmpfsemptyDir卷的用量当作容器内存用量，而不是本地临时性存储来统计。为本地临时性存储设置请求和约束值你可以使用ephemeral-storage来管理本地临时性存储。Pod中的每个Container可以设置以下属性：spec.containers[].resources.limits.ephemeral-storagespec.containers[].resources.requests.ephemeral-storageephemeral-storage的请求和约束值是按字节计量的。你可以使用一般整数或者定点数字加上下面的后缀来表达存储量：E、P、T、G、M、K。你也可以使用对应的2的幂级数来表达：Ei、Pi、Ti、Gi、Mi、Ki。例如，下面的表达式所表达的大致是同一个值：128974848,129e6,129M,123Mi在下面的例子中，Pod包含两个Container。每个Container请求2GiB大小的本地临时性存储。每个Container都设置了4GiB作为其本地临时性存储的约束值。因此，整个Pod的本地临时性存储请求是4GiB，且其本地临时性存储的约束为8GiB。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmp-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmpvolumes:-name:ephemeralemptyDir:{}带临时性存储的Pods的调度行为当你创建一个Pod时，Kubernetes调度器会为Pod选择一个节点来运行之。每个节点都有一个本地临时性存储的上限，是其可提供给Pods使用的总量。欲了解更多信息，可参考节点可分配资源节。调度器会确保所调度的Containers的资源请求总和不会超出节点的资源容量。临时性存储消耗的管理如果kubelet将本地临时性存储作为资源来管理，则kubelet会度量以下各处的存储用量：emptyDir卷，除了tmpfsemptyDir卷保存节点层面日志的目录可写入的容器镜像层如果某Pod的临时存储用量超出了你所允许的范围，kubelet会向其发出逐出（eviction）信号，触发该Pod被逐出所在节点。就容器层面的隔离而言，如果某容器的可写入镜像层和日志用量超出其存储约束，kubelet也会将所在的Pod标记为逐出候选。就Pod层面的隔离而言，kubelet会将Pod中所有容器的约束值相加，得到Pod存储约束的总值。如果所有容器的本地临时性存储用量总和加上Pod的emptyDir卷的用量超出Pod存储约束值，kubelet也会将该Pod标记为逐出候选。注意：如果kubelet没有度量本地临时性存储的用量，即使Pod的本地存储用量超出其约束值也不会被逐出。不过，如果用于可写入容器镜像层、节点层面日志或者emptyDir卷的文件系统中可用空间太少，节点会为自身设置本地存储不足的污点标签。这一污点会触发对那些无法容忍该污点的Pods的逐出操作。关于临时性本地存储的配置信息，请参考这里kubelet支持使用不同方式来度量Pod的存储用量：周期性扫描文件系统项目配额kubelet按预定周期执行扫描操作，检查emptyDir卷、容器日志目录以及可写入容器镜像层。这一扫描会度量存储空间用量。说明：在这种模式下，kubelet并不检查已删除文件所对应的、仍处于打开状态的文件描述符。如果你（或者容器）在emptyDir卷中创建了一个文件，写入一些内容之后再次打开该文件并执行了删除操作，所删除文件对应的inode仍然存在，直到你关闭该文件为止。kubelet不会将该文件所占用的空间视为已使用空间。为容器管理资源当你定义Pod时可以选择性地为每个容器设定所需要的资源数量。最常见的可设定资源是CPU和内存（RAM）大小；此外还有其他类型的资源。当你为Pod中的Container指定了资源请求时，调度器就利用该信息决定将Pod调度到哪个节点上。当你还为Container指定了资源约束时，kubelet就可以确保运行的容器不会使用超出所设约束的资源。kubelet还会为容器预留所请求数量的系统资源，供其使用。请求和约束如果Pod运行所在的节点具有足够的可用资源，容器可能（且可以）使用超出对应资源request属性所设置的资源量。不过，容器不可以使用超出其资源limit属性所设置的资源量。例如，如果你将容器的memory的请求量设置为256MiB，而该容器所处的Pod被调度到一个具有8GiB内存的节点上，并且该节点上没有其他Pods运行，那么该容器就可以尝试使用更多的内存。如果你将某容器的memory约束设置为4GiB，kubelet（和容器运行时）就会确保该约束生效。容器运行时会禁止容器使用超出所设置资源约束的资源。例如：当容器中进程尝试使用超出所允许内存量的资源时，系统内核会将尝试申请内存的进程终止，并引发内存不足（OOM）错误。约束值可以以被动方式来实现（系统会在发现违例时进行干预），或者通过强制生效的方式实现（系统会避免容器用量超出约束值）。不同的容器运行时采用不同方式来实现相同的限制。说明：如果某Container设置了自己的内存限制但未设置内存请求，Kubernetes自动为其设置与内存限制相匹配的请求值。类似的，如果某Container设置了CPU限制值但未设置CPU请求值，则Kubernetes自动为其设置CPU请求并使之与CPU限制值匹配。资源类型CPU和内存都是资源类型。每种资源类型具有其基本单位。CPU表达的是计算处理能力，其单位是KubernetesCPUs。内存的单位是字节。如果你使用的是Kubernetesv1.14或更高版本，则可以指定巨页（HugePage）资源。巨页是Linux特有的功能，节点内核在其中分配的内存块比默认页大小大得多。例如，在默认页面大小为4KiB的系统上，你可以指定约束hugepages-2Mi:80Mi。如果容器尝试分配40个2MiB大小的巨页（总共80MiB），则分配请求会失败。说明：你不能过量使用hugepages-*资源。这与memory和cpu资源不同。CPU和内存统称为计算资源，或简称为资源。计算资源的数量是可测量的，可以被请求、被分配、被消耗。它们与API资源不同。API资源（如Pod和Service）是可通过KubernetesAPI服务器读取和修改的对象。Pod和容器的资源请求和约束Pod中的每个容器都可以指定以下的一个或者多个值：spec.containers[].resources.limits.cpuspec.containers[].resources.limits.memoryspec.containers[].resources.limits.hugepages-<size>spec.containers[].resources.requests.cpuspec.containers[].resources.requests.memoryspec.containers[].resources.requests.hugepages-<size>尽管请求和限制值只能在单个容器上指定，我们仍可方便地计算出Pod的资源请求和约束。Pod对特定资源类型的请求/约束值是Pod中各容器对该类型资源的请求/约束值的总和。Kubernetes中的资源单位CPU的含义CPU资源的约束和请求以CPU为单位。Kubernetes中的一个CPU等于云平台上的1个vCPU/核和裸机Intel处理器上的1个超线程。你也可以表达带小数CPU的请求。spec.containers[].resources.requests.cpu为0.5的Container肯定能够获得请求1CPU的容器的一半CPU资源。表达式0.1等价于表达式100m，可以看作“100millicpu”。有些人说成是“一百毫cpu”，其实说的是同样的事情。具有小数点（如0.1）的请求由API转换为100m；最大精度是1m。因此，或许你应该优先考虑使用100m的形式。CPU总是按绝对数量来请求的，不可以使用相对数量；0.1的CPU在单核、双核、48核的机器上的意义是一样的。内存的含义内存的约束和请求以字节为单位。你可以使用以下后缀之一以一般整数或定点数字形式来表示内存：E、P、T、G、M、k。你也可以使用对应的2的幂数：Ei、Pi、Ti、Gi、Mi、Ki。例如，以下表达式所代表的是大致相同的值：128974848、129e6、129M、123Mi下面是个例子。以下Pod有两个Container。每个Container的请求为0.25cpu和64MiB（226字节）内存，每个容器的资源约束为0.5cpu和128MiB内存。你可以认为该Pod的资源请求为0.5cpu和128MiB内存，资源限制为1cpu和256MiB内存。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4env:-name:MYSQL_ROOT_PASSWORDvalue:passwordresources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m带资源请求的Pod如何调度当你创建一个Pod时，Kubernetes调度程序将为Pod选择一个节点。每个节点对每种资源类型都有一个容量上限：可为Pod提供的CPU和内存量。调度程序确保对于每种资源类型，所调度的容器的资源请求的总和小于节点的容量。请注意，尽管节点上的实际内存或CPU资源使用量非常低，如果容量检查失败，调度程序仍会拒绝在该节点上放置Pod。当稍后节点上资源用量增加，例如到达请求率的每日峰值区间时，节点上也不会出现资源不足的问题。带资源约束的Pod如何运行当kubelet启动Pod中的Container时，它会将CPU和内存约束信息传递给容器运行时。当使用Docker时：spec.containers[].resources.requests.cpu先被转换为可能是小数的基础值，再乘以1024。这个数值和2的较大者用作dockerrun命令中的--cpu-shares标志的值。spec.containers[].resources.limits.cpu先被转换为millicore值，再乘以100。其结果就是每100毫秒内容器可以使用的CPU时间总量，单位为微秒。在此期间（100ms），容器所使用的CPU时间不可以超过它被分配的时间。说明：默认的配额（Quota）周期为100毫秒。CPU配额的最小精度为1毫秒。spec.containers[].resources.limits.memory被转换为整数值，作为dockerrun命令中的--memory参数值。如果Container超过其内存限制，则可能会被终止。如果容器可重新启动，则与所有其他类型的运行时失效一样，kubelet将重新启动容器。如果一个Container内存用量超过其内存请求值，那么当节点内存不足时，容器所处的Pod可能被逐出。每个Container可能被允许也可能不被允许使用超过其CPU约束的处理时间。但是，容器不会由于CPU使用率过高而被杀死。要确定Container是否会由于资源约束而无法调度或被杀死，请参阅疑难解答部分。监控计算和内存资源用量Pod的资源使用情况是作为Pod状态的一部分来报告的。如果为集群配置了可选的监控工具，则可以直接从指标API或者监控工具获得Pod的资源使用情况。本地临时存储FEATURESTATE:Kubernetesv1.10[beta]节点通常还可以具有本地的临时性存储，由本地挂接的可写入设备或者有时也用RAM来提供支持。“临时（Ephemeral）”意味着对所存储的数据不提供长期可用性的保证。Pods通常可以使用临时性本地存储来实现缓冲区、保存日志等功能。kubelet可以为使用本地临时存储的Pods提供这种存储空间，允许后者使用emptyDir类型的卷将其挂载到容器中。kubelet也使用此类存储来保存节点层面的容器日志，容器镜像文件、以及运行中容器的可写入层。注意：如果节点失效，存储在临时性存储中的数据会丢失。你的应用不能对本地临时性存储的性能SLA（例如磁盘IOPS）作任何假定。作为一种beta阶段功能特性，Kubernetes允许你跟踪、预留和限制Pod可消耗的临时性本地存储数量。本地临时性存储的配置Kubernetes有两种方式支持节点上配置本地临时性存储：单一文件系统双文件系统采用这种配置时，你会把所有类型的临时性本地数据（包括emptyDir卷、可写入容器层、容器镜像、日志等）放到同一个文件系统中。作为最有效的kubelet配置方式，这意味着该文件系统是专门提供给Kubernetes（kubelet）来保存数据的。kubelet也会生成节点层面的容器日志，并按临时性本地存储的方式对待之。kubelet会将日志写入到所配置的日志目录（默认为/var/log）下的文件中；还会针对其他本地存储的数据使用同一个基础目录（默认为/var/lib/kubelet）。通常，/var/lib/kubelet和/var/log都是在系统的根文件系统中。kubelet的设计也考虑到这一点。你的集群节点当然可以包含其他的、并非用于Kubernetes的很多文件系统。kubelet能够度量其本地存储的用量。实现度量机制的前提是：LocalStorageCapacityIsolation特性门控被启用（默认状态），并且你已经对节点进行了配置，使之使用所支持的本地临时性储存配置方式之一如果你的节点配置不同于以上预期，kubelet就无法对临时性本地存储的资源约束实施限制。说明：kubelet会将tmpfsemptyDir卷的用量当作容器内存用量，而不是本地临时性存储来统计。为本地临时性存储设置请求和约束值你可以使用ephemeral-storage来管理本地临时性存储。Pod中的每个Container可以设置以下属性：spec.containers[].resources.limits.ephemeral-storagespec.containers[].resources.requests.ephemeral-storageephemeral-storage的请求和约束值是按字节计量的。你可以使用一般整数或者定点数字加上下面的后缀来表达存储量：E、P、T、G、M、K。你也可以使用对应的2的幂级数来表达：Ei、Pi、Ti、Gi、Mi、Ki。例如，下面的表达式所表达的大致是同一个值：128974848,129e6,129M,123Mi在下面的例子中，Pod包含两个Container。每个Container请求2GiB大小的本地临时性存储。每个Container都设置了4GiB作为其本地临时性存储的约束值。因此，整个Pod的本地临时性存储请求是4GiB，且其本地临时性存储的约束为8GiB。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmp-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmpvolumes:-name:ephemeralemptyDir:{}带临时性存储的Pods的调度行为当你创建一个Pod时，Kubernetes调度器会为Pod选择一个节点来运行之。每个节点都有一个本地临时性存储的上限，是其可提供给Pods使用的总量。欲了解更多信息，可参考节点可分配资源节。调度器会确保所调度的Containers的资源请求总和不会超出节点的资源容量。临时性存储消耗的管理如果kubelet将本地临时性存储作为资源来管理，则kubelet会度量以下各处的存储用量：emptyDir卷，除了tmpfsemptyDir卷保存节点层面日志的目录可写入的容器镜像层如果某Pod的临时存储用量超出了你所允许的范围，kubelet会向其发出逐出（eviction）信号，触发该Pod被逐出所在节点。就容器层面的隔离而言，如果某容器的可写入镜像层和日志用量超出其存储约束，kubelet也会将所在的Pod标记为逐出候选。就Pod层面的隔离而言，kubelet会将Pod中所有容器的约束值相加，得到Pod存储约束的总值。如果所有容器的本地临时性存储用量总和加上Pod的emptyDir卷的用量超出Pod存储约束值，kubelet也会将该Pod标记为逐出候选。注意：如果kubelet没有度量本地临时性存储的用量，即使Pod的本地存储用量超出其约束值也不会被逐出。不过，如果用于可写入容器镜像层、节点层面日志或者emptyDir卷的文件系统中可用空间太少，节点会为自身设置本地存储不足的污点标签。这一污点会触发对那些无法容忍该污点的Pods的逐出操作。关于临时性本地存储的配置信息，请参考这里kubelet支持使用不同方式来度量Pod的存储用量：周期性扫描文件系统项目配额kubelet按预定周期执行扫描操作，检查emptyDir卷、容器日志目录以及可写入容器镜像层。这一扫描会度量存储空间用量。说明：在这种模式下，kubelet并不检查已删除文件所对应的、仍处于打开状态的文件描述符。如果你（或者容器）在emptyDir卷中创建了一个文件，写入一些内容之后再次打开该文件并执行了删除操作，所删除文件对应的inode仍然存在，直到你关闭该文件为止。kubelet不会将该文件所占用的空间视为已使用空间。为容器管理资源当你定义Pod时可以选择性地为每个容器设定所需要的资源数量。最常见的可设定资源是CPU和内存（RAM）大小；此外还有其他类型的资源。当你为Pod中的Container指定了资源请求时，调度器就利用该信息决定将Pod调度到哪个节点上。当你还为Container指定了资源约束时，kubelet就可以确保运行的容器不会使用超出所设约束的资源。kubelet还会为容器预留所请求数量的系统资源，供其使用。请求和约束如果Pod运行所在的节点具有足够的可用资源，容器可能（且可以）使用超出对应资源request属性所设置的资源量。不过，容器不可以使用超出其资源limit属性所设置的资源量。例如，如果你将容器的memory的请求量设置为256MiB，而该容器所处的Pod被调度到一个具有8GiB内存的节点上，并且该节点上没有其他Pods运行，那么该容器就可以尝试使用更多的内存。如果你将某容器的memory约束设置为4GiB，kubelet（和容器运行时）就会确保该约束生效。容器运行时会禁止容器使用超出所设置资源约束的资源。例如：当容器中进程尝试使用超出所允许内存量的资源时，系统内核会将尝试申请内存的进程终止，并引发内存不足（OOM）错误。约束值可以以被动方式来实现（系统会在发现违例时进行干预），或者通过强制生效的方式实现（系统会避免容器用量超出约束值）。不同的容器运行时采用不同方式来实现相同的限制。说明：如果某Container设置了自己的内存限制但未设置内存请求，Kubernetes自动为其设置与内存限制相匹配的请求值。类似的，如果某Container设置了CPU限制值但未设置CPU请求值，则Kubernetes自动为其设置CPU请求并使之与CPU限制值匹配。资源类型CPU和内存都是资源类型。每种资源类型具有其基本单位。CPU表达的是计算处理能力，其单位是KubernetesCPUs。内存的单位是字节。如果你使用的是Kubernetesv1.14或更高版本，则可以指定巨页（HugePage）资源。巨页是Linux特有的功能，节点内核在其中分配的内存块比默认页大小大得多。例如，在默认页面大小为4KiB的系统上，你可以指定约束hugepages-2Mi:80Mi。如果容器尝试分配40个2MiB大小的巨页（总共80MiB），则分配请求会失败。说明：你不能过量使用hugepages-*资源。这与memory和cpu资源不同。CPU和内存统称为计算资源，或简称为资源。计算资源的数量是可测量的，可以被请求、被分配、被消耗。它们与API资源不同。API资源（如Pod和Service）是可通过KubernetesAPI服务器读取和修改的对象。Pod和容器的资源请求和约束Pod中的每个容器都可以指定以下的一个或者多个值：spec.containers[].resources.limits.cpuspec.containers[].resources.limits.memoryspec.containers[].resources.limits.hugepages-<size>spec.containers[].resources.requests.cpuspec.containers[].resources.requests.memoryspec.containers[].resources.requests.hugepages-<size>尽管请求和限制值只能在单个容器上指定，我们仍可方便地计算出Pod的资源请求和约束。Pod对特定资源类型的请求/约束值是Pod中各容器对该类型资源的请求/约束值的总和。Kubernetes中的资源单位CPU的含义CPU资源的约束和请求以CPU为单位。Kubernetes中的一个CPU等于云平台上的1个vCPU/核和裸机Intel处理器上的1个超线程。你也可以表达带小数CPU的请求。spec.containers[].resources.requests.cpu为0.5的Container肯定能够获得请求1CPU的容器的一半CPU资源。表达式0.1等价于表达式100m，可以看作“100millicpu”。有些人说成是“一百毫cpu”，其实说的是同样的事情。具有小数点（如0.1）的请求由API转换为100m；最大精度是1m。因此，或许你应该优先考虑使用100m的形式。CPU总是按绝对数量来请求的，不可以使用相对数量；0.1的CPU在单核、双核、48核的机器上的意义是一样的。内存的含义内存的约束和请求以字节为单位。你可以使用以下后缀之一以一般整数或定点数字形式来表示内存：E、P、T、G、M、k。你也可以使用对应的2的幂数：Ei、Pi、Ti、Gi、Mi、Ki。例如，以下表达式所代表的是大致相同的值：128974848、129e6、129M、123Mi下面是个例子。以下Pod有两个Container。每个Container的请求为0.25cpu和64MiB（226字节）内存，每个容器的资源约束为0.5cpu和128MiB内存。你可以认为该Pod的资源请求为0.5cpu和128MiB内存，资源限制为1cpu和256MiB内存。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4env:-name:MYSQL_ROOT_PASSWORDvalue:passwordresources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m带资源请求的Pod如何调度当你创建一个Pod时，Kubernetes调度程序将为Pod选择一个节点。每个节点对每种资源类型都有一个容量上限：可为Pod提供的CPU和内存量。调度程序确保对于每种资源类型，所调度的容器的资源请求的总和小于节点的容量。请注意，尽管节点上的实际内存或CPU资源使用量非常低，如果容量检查失败，调度程序仍会拒绝在该节点上放置Pod。当稍后节点上资源用量增加，例如到达请求率的每日峰值区间时，节点上也不会出现资源不足的问题。带资源约束的Pod如何运行当kubelet启动Pod中的Container时，它会将CPU和内存约束信息传递给容器运行时。当使用Docker时：spec.containers[].resources.requests.cpu先被转换为可能是小数的基础值，再乘以1024。这个数值和2的较大者用作dockerrun命令中的--cpu-shares标志的值。spec.containers[].resources.limits.cpu先被转换为millicore值，再乘以100。其结果就是每100毫秒内容器可以使用的CPU时间总量，单位为微秒。在此期间（100ms），容器所使用的CPU时间不可以超过它被分配的时间。说明：默认的配额（Quota）周期为100毫秒。CPU配额的最小精度为1毫秒。spec.containers[].resources.limits.memory被转换为整数值，作为dockerrun命令中的--memory参数值。如果Container超过其内存限制，则可能会被终止。如果容器可重新启动，则与所有其他类型的运行时失效一样，kubelet将重新启动容器。如果一个Container内存用量超过其内存请求值，那么当节点内存不足时，容器所处的Pod可能被逐出。每个Container可能被允许也可能不被允许使用超过其CPU约束的处理时间。但是，容器不会由于CPU使用率过高而被杀死。要确定Container是否会由于资源约束而无法调度或被杀死，请参阅疑难解答部分。监控计算和内存资源用量Pod的资源使用情况是作为Pod状态的一部分来报告的。如果为集群配置了可选的监控工具，则可以直接从指标API或者监控工具获得Pod的资源使用情况。本地临时存储FEATURESTATE:Kubernetesv1.10[beta]节点通常还可以具有本地的临时性存储，由本地挂接的可写入设备或者有时也用RAM来提供支持。“临时（Ephemeral）”意味着对所存储的数据不提供长期可用性的保证。Pods通常可以使用临时性本地存储来实现缓冲区、保存日志等功能。kubelet可以为使用本地临时存储的Pods提供这种存储空间，允许后者使用emptyDir类型的卷将其挂载到容器中。kubelet也使用此类存储来保存节点层面的容器日志，容器镜像文件、以及运行中容器的可写入层。注意：如果节点失效，存储在临时性存储中的数据会丢失。你的应用不能对本地临时性存储的性能SLA（例如磁盘IOPS）作任何假定。作为一种beta阶段功能特性，Kubernetes允许你跟踪、预留和限制Pod可消耗的临时性本地存储数量。本地临时性存储的配置Kubernetes有两种方式支持节点上配置本地临时性存储：单一文件系统双文件系统采用这种配置时，你会把所有类型的临时性本地数据（包括emptyDir卷、可写入容器层、容器镜像、日志等）放到同一个文件系统中。作为最有效的kubelet配置方式，这意味着该文件系统是专门提供给Kubernetes（kubelet）来保存数据的。kubelet也会生成节点层面的容器日志，并按临时性本地存储的方式对待之。kubelet会将日志写入到所配置的日志目录（默认为/var/log）下的文件中；还会针对其他本地存储的数据使用同一个基础目录（默认为/var/lib/kubelet）。通常，/var/lib/kubelet和/var/log都是在系统的根文件系统中。kubelet的设计也考虑到这一点。你的集群节点当然可以包含其他的、并非用于Kubernetes的很多文件系统。kubelet能够度量其本地存储的用量。实现度量机制的前提是：LocalStorageCapacityIsolation特性门控被启用（默认状态），并且你已经对节点进行了配置，使之使用所支持的本地临时性储存配置方式之一如果你的节点配置不同于以上预期，kubelet就无法对临时性本地存储的资源约束实施限制。说明：kubelet会将tmpfsemptyDir卷的用量当作容器内存用量，而不是本地临时性存储来统计。为本地临时性存储设置请求和约束值你可以使用ephemeral-storage来管理本地临时性存储。Pod中的每个Container可以设置以下属性：spec.containers[].resources.limits.ephemeral-storagespec.containers[].resources.requests.ephemeral-storageephemeral-storage的请求和约束值是按字节计量的。你可以使用一般整数或者定点数字加上下面的后缀来表达存储量：E、P、T、G、M、K。你也可以使用对应的2的幂级数来表达：Ei、Pi、Ti、Gi、Mi、Ki。例如，下面的表达式所表达的大致是同一个值：128974848,129e6,129M,123Mi在下面的例子中，Pod包含两个Container。每个Container请求2GiB大小的本地临时性存储。每个Container都设置了4GiB作为其本地临时性存储的约束值。因此，整个Pod的本地临时性存储请求是4GiB，且其本地临时性存储的约束为8GiB。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmp-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmpvolumes:-name:ephemeralemptyDir:{}带临时性存储的Pods的调度行为当你创建一个Pod时，Kubernetes调度器会为Pod选择一个节点来运行之。每个节点都有一个本地临时性存储的上限，是其可提供给Pods使用的总量。欲了解更多信息，可参考节点可分配资源节。调度器会确保所调度的Containers的资源请求总和不会超出节点的资源容量。临时性存储消耗的管理如果kubelet将本地临时性存储作为资源来管理，则kubelet会度量以下各处的存储用量：emptyDir卷，除了tmpfsemptyDir卷保存节点层面日志的目录可写入的容器镜像层如果某Pod的临时存储用量超出了你所允许的范围，kubelet会向其发出逐出（eviction）信号，触发该Pod被逐出所在节点。就容器层面的隔离而言，如果某容器的可写入镜像层和日志用量超出其存储约束，kubelet也会将所在的Pod标记为逐出候选。就Pod层面的隔离而言，kubelet会将Pod中所有容器的约束值相加，得到Pod存储约束的总值。如果所有容器的本地临时性存储用量总和加上Pod的emptyDir卷的用量超出Pod存储约束值，kubelet也会将该Pod标记为逐出候选。注意：如果kubelet没有度量本地临时性存储的用量，即使Pod的本地存储用量超出其约束值也不会被逐出。不过，如果用于可写入容器镜像层、节点层面日志或者emptyDir卷的文件系统中可用空间太少，节点会为自身设置本地存储不足的污点标签。这一污点会触发对那些无法容忍该污点的Pods的逐出操作。关于临时性本地存储的配置信息，请参考这里kubelet支持使用不同方式来度量Pod的存储用量：周期性扫描文件系统项目配额kubelet按预定周期执行扫描操作，检查emptyDir卷、容器日志目录以及可写入容器镜像层。这一扫描会度量存储空间用量。说明：在这种模式下，kubelet并不检查已删除文件所对应的、仍处于打开状态的文件描述符。如果你（或者容器）在emptyDir卷中创建了一个文件，写入一些内容之后再次打开该文件并执行了删除操作，所删除文件对应的inode仍然存在，直到你关闭该文件为止。kubelet不会将该文件所占用的空间视为已使用空间。为容器管理资源当你定义Pod时可以选择性地为每个容器设定所需要的资源数量。最常见的可设定资源是CPU和内存（RAM）大小；此外还有其他类型的资源。当你为Pod中的Container指定了资源请求时，调度器就利用该信息决定将Pod调度到哪个节点上。当你还为Container指定了资源约束时，kubelet就可以确保运行的容器不会使用超出所设约束的资源。kubelet还会为容器预留所请求数量的系统资源，供其使用。请求和约束如果Pod运行所在的节点具有足够的可用资源，容器可能（且可以）使用超出对应资源request属性所设置的资源量。不过，容器不可以使用超出其资源limit属性所设置的资源量。例如，如果你将容器的memory的请求量设置为256MiB，而该容器所处的Pod被调度到一个具有8GiB内存的节点上，并且该节点上没有其他Pods运行，那么该容器就可以尝试使用更多的内存。如果你将某容器的memory约束设置为4GiB，kubelet（和容器运行时）就会确保该约束生效。容器运行时会禁止容器使用超出所设置资源约束的资源。例如：当容器中进程尝试使用超出所允许内存量的资源时，系统内核会将尝试申请内存的进程终止，并引发内存不足（OOM）错误。约束值可以以被动方式来实现（系统会在发现违例时进行干预），或者通过强制生效的方式实现（系统会避免容器用量超出约束值）。不同的容器运行时采用不同方式来实现相同的限制。说明：如果某Container设置了自己的内存限制但未设置内存请求，Kubernetes自动为其设置与内存限制相匹配的请求值。类似的，如果某Container设置了CPU限制值但未设置CPU请求值，则Kubernetes自动为其设置CPU请求并使之与CPU限制值匹配。资源类型CPU和内存都是资源类型。每种资源类型具有其基本单位。CPU表达的是计算处理能力，其单位是KubernetesCPUs。内存的单位是字节。如果你使用的是Kubernetesv1.14或更高版本，则可以指定巨页（HugePage）资源。巨页是Linux特有的功能，节点内核在其中分配的内存块比默认页大小大得多。例如，在默认页面大小为4KiB的系统上，你可以指定约束hugepages-2Mi:80Mi。如果容器尝试分配40个2MiB大小的巨页（总共80MiB），则分配请求会失败。说明：你不能过量使用hugepages-*资源。这与memory和cpu资源不同。CPU和内存统称为计算资源，或简称为资源。计算资源的数量是可测量的，可以被请求、被分配、被消耗。它们与API资源不同。API资源（如Pod和Service）是可通过KubernetesAPI服务器读取和修改的对象。Pod和容器的资源请求和约束Pod中的每个容器都可以指定以下的一个或者多个值：spec.containers[].resources.limits.cpuspec.containers[].resources.limits.memoryspec.containers[].resources.limits.hugepages-<size>spec.containers[].resources.requests.cpuspec.containers[].resources.requests.memoryspec.containers[].resources.requests.hugepages-<size>尽管请求和限制值只能在单个容器上指定，我们仍可方便地计算出Pod的资源请求和约束。Pod对特定资源类型的请求/约束值是Pod中各容器对该类型资源的请求/约束值的总和。Kubernetes中的资源单位CPU的含义CPU资源的约束和请求以CPU为单位。Kubernetes中的一个CPU等于云平台上的1个vCPU/核和裸机Intel处理器上的1个超线程。你也可以表达带小数CPU的请求。spec.containers[].resources.requests.cpu为0.5的Container肯定能够获得请求1CPU的容器的一半CPU资源。表达式0.1等价于表达式100m，可以看作“100millicpu”。有些人说成是“一百毫cpu”，其实说的是同样的事情。具有小数点（如0.1）的请求由API转换为100m；最大精度是1m。因此，或许你应该优先考虑使用100m的形式。CPU总是按绝对数量来请求的，不可以使用相对数量；0.1的CPU在单核、双核、48核的机器上的意义是一样的。内存的含义内存的约束和请求以字节为单位。你可以使用以下后缀之一以一般整数或定点数字形式来表示内存：E、P、T、G、M、k。你也可以使用对应的2的幂数：Ei、Pi、Ti、Gi、Mi、Ki。例如，以下表达式所代表的是大致相同的值：128974848、129e6、129M、123Mi下面是个例子。以下Pod有两个Container。每个Container的请求为0.25cpu和64MiB（226字节）内存，每个容器的资源约束为0.5cpu和128MiB内存。你可以认为该Pod的资源请求为0.5cpu和128MiB内存，资源限制为1cpu和256MiB内存。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4env:-name:MYSQL_ROOT_PASSWORDvalue:passwordresources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m带资源请求的Pod如何调度当你创建一个Pod时，Kubernetes调度程序将为Pod选择一个节点。每个节点对每种资源类型都有一个容量上限：可为Pod提供的CPU和内存量。调度程序确保对于每种资源类型，所调度的容器的资源请求的总和小于节点的容量。请注意，尽管节点上的实际内存或CPU资源使用量非常低，如果容量检查失败，调度程序仍会拒绝在该节点上放置Pod。当稍后节点上资源用量增加，例如到达请求率的每日峰值区间时，节点上也不会出现资源不足的问题。带资源约束的Pod如何运行当kubelet启动Pod中的Container时，它会将CPU和内存约束信息传递给容器运行时。当使用Docker时：spec.containers[].resources.requests.cpu先被转换为可能是小数的基础值，再乘以1024。这个数值和2的较大者用作dockerrun命令中的--cpu-shares标志的值。spec.containers[].resources.limits.cpu先被转换为millicore值，再乘以100。其结果就是每100毫秒内容器可以使用的CPU时间总量，单位为微秒。在此期间（100ms），容器所使用的CPU时间不可以超过它被分配的时间。说明：默认的配额（Quota）周期为100毫秒。CPU配额的最小精度为1毫秒。spec.containers[].resources.limits.memory被转换为整数值，作为dockerrun命令中的--memory参数值。如果Container超过其内存限制，则可能会被终止。如果容器可重新启动，则与所有其他类型的运行时失效一样，kubelet将重新启动容器。如果一个Container内存用量超过其内存请求值，那么当节点内存不足时，容器所处的Pod可能被逐出。每个Container可能被允许也可能不被允许使用超过其CPU约束的处理时间。但是，容器不会由于CPU使用率过高而被杀死。要确定Container是否会由于资源约束而无法调度或被杀死，请参阅疑难解答部分。监控计算和内存资源用量Pod的资源使用情况是作为Pod状态的一部分来报告的。如果为集群配置了可选的监控工具，则可以直接从指标API或者监控工具获得Pod的资源使用情况。本地临时存储FEATURESTATE:Kubernetesv1.10[beta]节点通常还可以具有本地的临时性存储，由本地挂接的可写入设备或者有时也用RAM来提供支持。“临时（Ephemeral）”意味着对所存储的数据不提供长期可用性的保证。Pods通常可以使用临时性本地存储来实现缓冲区、保存日志等功能。kubelet可以为使用本地临时存储的Pods提供这种存储空间，允许后者使用emptyDir类型的卷将其挂载到容器中。kubelet也使用此类存储来保存节点层面的容器日志，容器镜像文件、以及运行中容器的可写入层。注意：如果节点失效，存储在临时性存储中的数据会丢失。你的应用不能对本地临时性存储的性能SLA（例如磁盘IOPS）作任何假定。作为一种beta阶段功能特性，Kubernetes允许你跟踪、预留和限制Pod可消耗的临时性本地存储数量。本地临时性存储的配置Kubernetes有两种方式支持节点上配置本地临时性存储：单一文件系统双文件系统采用这种配置时，你会把所有类型的临时性本地数据（包括emptyDir卷、可写入容器层、容器镜像、日志等）放到同一个文件系统中。作为最有效的kubelet配置方式，这意味着该文件系统是专门提供给Kubernetes（kubelet）来保存数据的。kubelet也会生成节点层面的容器日志，并按临时性本地存储的方式对待之。kubelet会将日志写入到所配置的日志目录（默认为/var/log）下的文件中；还会针对其他本地存储的数据使用同一个基础目录（默认为/var/lib/kubelet）。通常，/var/lib/kubelet和/var/log都是在系统的根文件系统中。kubelet的设计也考虑到这一点。你的集群节点当然可以包含其他的、并非用于Kubernetes的很多文件系统。kubelet能够度量其本地存储的用量。实现度量机制的前提是：LocalStorageCapacityIsolation特性门控被启用（默认状态），并且你已经对节点进行了配置，使之使用所支持的本地临时性储存配置方式之一如果你的节点配置不同于以上预期，kubelet就无法对临时性本地存储的资源约束实施限制。说明：kubelet会将tmpfsemptyDir卷的用量当作容器内存用量，而不是本地临时性存储来统计。为本地临时性存储设置请求和约束值你可以使用ephemeral-storage来管理本地临时性存储。Pod中的每个Container可以设置以下属性：spec.containers[].resources.limits.ephemeral-storagespec.containers[].resources.requests.ephemeral-storageephemeral-storage的请求和约束值是按字节计量的。你可以使用一般整数或者定点数字加上下面的后缀来表达存储量：E、P、T、G、M、K。你也可以使用对应的2的幂级数来表达：Ei、Pi、Ti、Gi、Mi、Ki。例如，下面的表达式所表达的大致是同一个值：128974848,129e6,129M,123Mi在下面的例子中，Pod包含两个Container。每个Container请求2GiB大小的本地临时性存储。每个Container都设置了4GiB作为其本地临时性存储的约束值。因此，整个Pod的本地临时性存储请求是4GiB，且其本地临时性存储的约束为8GiB。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmp-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmpvolumes:-name:ephemeralemptyDir:{}带临时性存储的Pods的调度行为当你创建一个Pod时，Kubernetes调度器会为Pod选择一个节点来运行之。每个节点都有一个本地临时性存储的上限，是其可提供给Pods使用的总量。欲了解更多信息，可参考节点可分配资源节。调度器会确保所调度的Containers的资源请求总和不会超出节点的资源容量。临时性存储消耗的管理如果kubelet将本地临时性存储作为资源来管理，则kubelet会度量以下各处的存储用量：emptyDir卷，除了tmpfsemptyDir卷保存节点层面日志的目录可写入的容器镜像层如果某Pod的临时存储用量超出了你所允许的范围，kubelet会向其发出逐出（eviction）信号，触发该Pod被逐出所在节点。就容器层面的隔离而言，如果某容器的可写入镜像层和日志用量超出其存储约束，kubelet也会将所在的Pod标记为逐出候选。就Pod层面的隔离而言，kubelet会将Pod中所有容器的约束值相加，得到Pod存储约束的总值。如果所有容器的本地临时性存储用量总和加上Pod的emptyDir卷的用量超出Pod存储约束值，kubelet也会将该Pod标记为逐出候选。注意：如果kubelet没有度量本地临时性存储的用量，即使Pod的本地存储用量超出其约束值也不会被逐出。不过，如果用于可写入容器镜像层、节点层面日志或者emptyDir卷的文件系统中可用空间太少，节点会为自身设置本地存储不足的污点标签。这一污点会触发对那些无法容忍该污点的Pods的逐出操作。关于临时性本地存储的配置信息，请参考这里kubelet支持使用不同方式来度量Pod的存储用量：周期性扫描文件系统项目配额kubelet按预定周期执行扫描操作，检查emptyDir卷、容器日志目录以及可写入容器镜像层。这一扫描会度量存储空间用量。说明：在这种模式下，kubelet并不检查已删除文件所对应的、仍处于打开状态的文件描述符。如果你（或者容器）在emptyDir卷中创建了一个文件，写入一些内容之后再次打开该文件并执行了删除操作，所删除文件对应的inode仍然存在，直到你关闭该文件为止。kubelet不会将该文件所占用的空间视为已使用空间。为容器管理资源当你定义Pod时可以选择性地为每个容器设定所需要的资源数量。最常见的可设定资源是CPU和内存（RAM）大小；此外还有其他类型的资源。当你为Pod中的Container指定了资源请求时，调度器就利用该信息决定将Pod调度到哪个节点上。当你还为Container指定了资源约束时，kubelet就可以确保运行的容器不会使用超出所设约束的资源。kubelet还会为容器预留所请求数量的系统资源，供其使用。请求和约束如果Pod运行所在的节点具有足够的可用资源，容器可能（且可以）使用超出对应资源request属性所设置的资源量。不过，容器不可以使用超出其资源limit属性所设置的资源量。例如，如果你将容器的memory的请求量设置为256MiB，而该容器所处的Pod被调度到一个具有8GiB内存的节点上，并且该节点上没有其他Pods运行，那么该容器就可以尝试使用更多的内存。如果你将某容器的memory约束设置为4GiB，kubelet（和容器运行时）就会确保该约束生效。容器运行时会禁止容器使用超出所设置资源约束的资源。例如：当容器中进程尝试使用超出所允许内存量的资源时，系统内核会将尝试申请内存的进程终止，并引发内存不足（OOM）错误。约束值可以以被动方式来实现（系统会在发现违例时进行干预），或者通过强制生效的方式实现（系统会避免容器用量超出约束值）。不同的容器运行时采用不同方式来实现相同的限制。说明：如果某Container设置了自己的内存限制但未设置内存请求，Kubernetes自动为其设置与内存限制相匹配的请求值。类似的，如果某Container设置了CPU限制值但未设置CPU请求值，则Kubernetes自动为其设置CPU请求并使之与CPU限制值匹配。资源类型CPU和内存都是资源类型。每种资源类型具有其基本单位。CPU表达的是计算处理能力，其单位是KubernetesCPUs。内存的单位是字节。如果你使用的是Kubernetesv1.14或更高版本，则可以指定巨页（HugePage）资源。巨页是Linux特有的功能，节点内核在其中分配的内存块比默认页大小大得多。例如，在默认页面大小为4KiB的系统上，你可以指定约束hugepages-2Mi:80Mi。如果容器尝试分配40个2MiB大小的巨页（总共80MiB），则分配请求会失败。说明：你不能过量使用hugepages-*资源。这与memory和cpu资源不同。CPU和内存统称为计算资源，或简称为资源。计算资源的数量是可测量的，可以被请求、被分配、被消耗。它们与API资源不同。API资源（如Pod和Service）是可通过KubernetesAPI服务器读取和修改的对象。Pod和容器的资源请求和约束Pod中的每个容器都可以指定以下的一个或者多个值：spec.containers[].resources.limits.cpuspec.containers[].resources.limits.memoryspec.containers[].resources.limits.hugepages-<size>spec.containers[].resources.requests.cpuspec.containers[].resources.requests.memoryspec.containers[].resources.requests.hugepages-<size>尽管请求和限制值只能在单个容器上指定，我们仍可方便地计算出Pod的资源请求和约束。Pod对特定资源类型的请求/约束值是Pod中各容器对该类型资源的请求/约束值的总和。Kubernetes中的资源单位CPU的含义CPU资源的约束和请求以CPU为单位。Kubernetes中的一个CPU等于云平台上的1个vCPU/核和裸机Intel处理器上的1个超线程。你也可以表达带小数CPU的请求。spec.containers[].resources.requests.cpu为0.5的Container肯定能够获得请求1CPU的容器的一半CPU资源。表达式0.1等价于表达式100m，可以看作“100millicpu”。有些人说成是“一百毫cpu”，其实说的是同样的事情。具有小数点（如0.1）的请求由API转换为100m；最大精度是1m。因此，或许你应该优先考虑使用100m的形式。CPU总是按绝对数量来请求的，不可以使用相对数量；0.1的CPU在单核、双核、48核的机器上的意义是一样的。内存的含义内存的约束和请求以字节为单位。你可以使用以下后缀之一以一般整数或定点数字形式来表示内存：E、P、T、G、M、k。你也可以使用对应的2的幂数：Ei、Pi、Ti、Gi、Mi、Ki。例如，以下表达式所代表的是大致相同的值：128974848、129e6、129M、123Mi下面是个例子。以下Pod有两个Container。每个Container的请求为0.25cpu和64MiB（226字节）内存，每个容器的资源约束为0.5cpu和128MiB内存。你可以认为该Pod的资源请求为0.5cpu和128MiB内存，资源限制为1cpu和256MiB内存。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4env:-name:MYSQL_ROOT_PASSWORDvalue:passwordresources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m带资源请求的Pod如何调度当你创建一个Pod时，Kubernetes调度程序将为Pod选择一个节点。每个节点对每种资源类型都有一个容量上限：可为Pod提供的CPU和内存量。调度程序确保对于每种资源类型，所调度的容器的资源请求的总和小于节点的容量。请注意，尽管节点上的实际内存或CPU资源使用量非常低，如果容量检查失败，调度程序仍会拒绝在该节点上放置Pod。当稍后节点上资源用量增加，例如到达请求率的每日峰值区间时，节点上也不会出现资源不足的问题。带资源约束的Pod如何运行当kubelet启动Pod中的Container时，它会将CPU和内存约束信息传递给容器运行时。当使用Docker时：spec.containers[].resources.requests.cpu先被转换为可能是小数的基础值，再乘以1024。这个数值和2的较大者用作dockerrun命令中的--cpu-shares标志的值。spec.containers[].resources.limits.cpu先被转换为millicore值，再乘以100。其结果就是每100毫秒内容器可以使用的CPU时间总量，单位为微秒。在此期间（100ms），容器所使用的CPU时间不可以超过它被分配的时间。说明：默认的配额（Quota）周期为100毫秒。CPU配额的最小精度为1毫秒。spec.containers[].resources.limits.memory被转换为整数值，作为dockerrun命令中的--memory参数值。如果Container超过其内存限制，则可能会被终止。如果容器可重新启动，则与所有其他类型的运行时失效一样，kubelet将重新启动容器。如果一个Container内存用量超过其内存请求值，那么当节点内存不足时，容器所处的Pod可能被逐出。每个Container可能被允许也可能不被允许使用超过其CPU约束的处理时间。但是，容器不会由于CPU使用率过高而被杀死。要确定Container是否会由于资源约束而无法调度或被杀死，请参阅疑难解答部分。监控计算和内存资源用量Pod的资源使用情况是作为Pod状态的一部分来报告的。如果为集群配置了可选的监控工具，则可以直接从指标API或者监控工具获得Pod的资源使用情况。本地临时存储FEATURESTATE:Kubernetesv1.10[beta]节点通常还可以具有本地的临时性存储，由本地挂接的可写入设备或者有时也用RAM来提供支持。“临时（Ephemeral）”意味着对所存储的数据不提供长期可用性的保证。Pods通常可以使用临时性本地存储来实现缓冲区、保存日志等功能。kubelet可以为使用本地临时存储的Pods提供这种存储空间，允许后者使用emptyDir类型的卷将其挂载到容器中。kubelet也使用此类存储来保存节点层面的容器日志，容器镜像文件、以及运行中容器的可写入层。注意：如果节点失效，存储在临时性存储中的数据会丢失。你的应用不能对本地临时性存储的性能SLA（例如磁盘IOPS）作任何假定。作为一种beta阶段功能特性，Kubernetes允许你跟踪、预留和限制Pod可消耗的临时性本地存储数量。本地临时性存储的配置Kubernetes有两种方式支持节点上配置本地临时性存储：单一文件系统双文件系统采用这种配置时，你会把所有类型的临时性本地数据（包括emptyDir卷、可写入容器层、容器镜像、日志等）放到同一个文件系统中。作为最有效的kubelet配置方式，这意味着该文件系统是专门提供给Kubernetes（kubelet）来保存数据的。kubelet也会生成节点层面的容器日志，并按临时性本地存储的方式对待之。kubelet会将日志写入到所配置的日志目录（默认为/var/log）下的文件中；还会针对其他本地存储的数据使用同一个基础目录（默认为/var/lib/kubelet）。通常，/var/lib/kubelet和/var/log都是在系统的根文件系统中。kubelet的设计也考虑到这一点。你的集群节点当然可以包含其他的、并非用于Kubernetes的很多文件系统。kubelet能够度量其本地存储的用量。实现度量机制的前提是：LocalStorageCapacityIsolation特性门控被启用（默认状态），并且你已经对节点进行了配置，使之使用所支持的本地临时性储存配置方式之一如果你的节点配置不同于以上预期，kubelet就无法对临时性本地存储的资源约束实施限制。说明：kubelet会将tmpfsemptyDir卷的用量当作容器内存用量，而不是本地临时性存储来统计。为本地临时性存储设置请求和约束值你可以使用ephemeral-storage来管理本地临时性存储。Pod中的每个Container可以设置以下属性：spec.containers[].resources.limits.ephemeral-storagespec.containers[].resources.requests.ephemeral-storageephemeral-storage的请求和约束值是按字节计量的。你可以使用一般整数或者定点数字加上下面的后缀来表达存储量：E、P、T、G、M、K。你也可以使用对应的2的幂级数来表达：Ei、Pi、Ti、Gi、Mi、Ki。例如，下面的表达式所表达的大致是同一个值：128974848,129e6,129M,123Mi在下面的例子中，Pod包含两个Container。每个Container请求2GiB大小的本地临时性存储。每个Container都设置了4GiB作为其本地临时性存储的约束值。因此，整个Pod的本地临时性存储请求是4GiB，且其本地临时性存储的约束为8GiB。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmp-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmpvolumes:-name:ephemeralemptyDir:{}带临时性存储的Pods的调度行为当你创建一个Pod时，Kubernetes调度器会为Pod选择一个节点来运行之。每个节点都有一个本地临时性存储的上限，是其可提供给Pods使用的总量。欲了解更多信息，可参考节点可分配资源节。调度器会确保所调度的Containers的资源请求总和不会超出节点的资源容量。临时性存储消耗的管理如果kubelet将本地临时性存储作为资源来管理，则kubelet会度量以下各处的存储用量：emptyDir卷，除了tmpfsemptyDir卷保存节点层面日志的目录可写入的容器镜像层如果某Pod的临时存储用量超出了你所允许的范围，kubelet会向其发出逐出（eviction）信号，触发该Pod被逐出所在节点。就容器层面的隔离而言，如果某容器的可写入镜像层和日志用量超出其存储约束，kubelet也会将所在的Pod标记为逐出候选。就Pod层面的隔离而言，kubelet会将Pod中所有容器的约束值相加，得到Pod存储约束的总值。如果所有容器的本地临时性存储用量总和加上Pod的emptyDir卷的用量超出Pod存储约束值，kubelet也会将该Pod标记为逐出候选。注意：如果kubelet没有度量本地临时性存储的用量，即使Pod的本地存储用量超出其约束值也不会被逐出。不过，如果用于可写入容器镜像层、节点层面日志或者emptyDir卷的文件系统中可用空间太少，节点会为自身设置本地存储不足的污点标签。这一污点会触发对那些无法容忍该污点的Pods的逐出操作。关于临时性本地存储的配置信息，请参考这里kubelet支持使用不同方式来度量Pod的存储用量：周期性扫描文件系统项目配额kubelet按预定周期执行扫描操作，检查emptyDir卷、容器日志目录以及可写入容器镜像层。这一扫描会度量存储空间用量。说明：在这种模式下，kubelet并不检查已删除文件所对应的、仍处于打开状态的文件描述符。如果你（或者容器）在emptyDir卷中创建了一个文件，写入一些内容之后再次打开该文件并执行了删除操作，所删除文件对应的inode仍然存在，直到你关闭该文件为止。kubelet不会将该文件所占用的空间视为已使用空间。为容器管理资源当你定义Pod时可以选择性地为每个容器设定所需要的资源数量。最常见的可设定资源是CPU和内存（RAM）大小；此外还有其他类型的资源。当你为Pod中的Container指定了资源请求时，调度器就利用该信息决定将Pod调度到哪个节点上。当你还为Container指定了资源约束时，kubelet就可以确保运行的容器不会使用超出所设约束的资源。kubelet还会为容器预留所请求数量的系统资源，供其使用。请求和约束如果Pod运行所在的节点具有足够的可用资源，容器可能（且可以）使用超出对应资源request属性所设置的资源量。不过，容器不可以使用超出其资源limit属性所设置的资源量。例如，如果你将容器的memory的请求量设置为256MiB，而该容器所处的Pod被调度到一个具有8GiB内存的节点上，并且该节点上没有其他Pods运行，那么该容器就可以尝试使用更多的内存。如果你将某容器的memory约束设置为4GiB，kubelet（和容器运行时）就会确保该约束生效。容器运行时会禁止容器使用超出所设置资源约束的资源。例如：当容器中进程尝试使用超出所允许内存量的资源时，系统内核会将尝试申请内存的进程终止，并引发内存不足（OOM）错误。约束值可以以被动方式来实现（系统会在发现违例时进行干预），或者通过强制生效的方式实现（系统会避免容器用量超出约束值）。不同的容器运行时采用不同方式来实现相同的限制。说明：如果某Container设置了自己的内存限制但未设置内存请求，Kubernetes自动为其设置与内存限制相匹配的请求值。类似的，如果某Container设置了CPU限制值但未设置CPU请求值，则Kubernetes自动为其设置CPU请求并使之与CPU限制值匹配。资源类型CPU和内存都是资源类型。每种资源类型具有其基本单位。CPU表达的是计算处理能力，其单位是KubernetesCPUs。内存的单位是字节。如果你使用的是Kubernetesv1.14或更高版本，则可以指定巨页（HugePage）资源。巨页是Linux特有的功能，节点内核在其中分配的内存块比默认页大小大得多。例如，在默认页面大小为4KiB的系统上，你可以指定约束hugepages-2Mi:80Mi。如果容器尝试分配40个2MiB大小的巨页（总共80MiB），则分配请求会失败。说明：你不能过量使用hugepages-*资源。这与memory和cpu资源不同。CPU和内存统称为计算资源，或简称为资源。计算资源的数量是可测量的，可以被请求、被分配、被消耗。它们与API资源不同。API资源（如Pod和Service）是可通过KubernetesAPI服务器读取和修改的对象。Pod和容器的资源请求和约束Pod中的每个容器都可以指定以下的一个或者多个值：spec.containers[].resources.limits.cpuspec.containers[].resources.limits.memoryspec.containers[].resources.limits.hugepages-<size>spec.containers[].resources.requests.cpuspec.containers[].resources.requests.memoryspec.containers[].resources.requests.hugepages-<size>尽管请求和限制值只能在单个容器上指定，我们仍可方便地计算出Pod的资源请求和约束。Pod对特定资源类型的请求/约束值是Pod中各容器对该类型资源的请求/约束值的总和。Kubernetes中的资源单位CPU的含义CPU资源的约束和请求以CPU为单位。Kubernetes中的一个CPU等于云平台上的1个vCPU/核和裸机Intel处理器上的1个超线程。你也可以表达带小数CPU的请求。spec.containers[].resources.requests.cpu为0.5的Container肯定能够获得请求1CPU的容器的一半CPU资源。表达式0.1等价于表达式100m，可以看作“100millicpu”。有些人说成是“一百毫cpu”，其实说的是同样的事情。具有小数点（如0.1）的请求由API转换为100m；最大精度是1m。因此，或许你应该优先考虑使用100m的形式。CPU总是按绝对数量来请求的，不可以使用相对数量；0.1的CPU在单核、双核、48核的机器上的意义是一样的。内存的含义内存的约束和请求以字节为单位。你可以使用以下后缀之一以一般整数或定点数字形式来表示内存：E、P、T、G、M、k。你也可以使用对应的2的幂数：Ei、Pi、Ti、Gi、Mi、Ki。例如，以下表达式所代表的是大致相同的值：128974848、129e6、129M、123Mi下面是个例子。以下Pod有两个Container。每个Container的请求为0.25cpu和64MiB（226字节）内存，每个容器的资源约束为0.5cpu和128MiB内存。你可以认为该Pod的资源请求为0.5cpu和128MiB内存，资源限制为1cpu和256MiB内存。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4env:-name:MYSQL_ROOT_PASSWORDvalue:passwordresources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m带资源请求的Pod如何调度当你创建一个Pod时，Kubernetes调度程序将为Pod选择一个节点。每个节点对每种资源类型都有一个容量上限：可为Pod提供的CPU和内存量。调度程序确保对于每种资源类型，所调度的容器的资源请求的总和小于节点的容量。请注意，尽管节点上的实际内存或CPU资源使用量非常低，如果容量检查失败，调度程序仍会拒绝在该节点上放置Pod。当稍后节点上资源用量增加，例如到达请求率的每日峰值区间时，节点上也不会出现资源不足的问题。带资源约束的Pod如何运行当kubelet启动Pod中的Container时，它会将CPU和内存约束信息传递给容器运行时。当使用Docker时：spec.containers[].resources.requests.cpu先被转换为可能是小数的基础值，再乘以1024。这个数值和2的较大者用作dockerrun命令中的--cpu-shares标志的值。spec.containers[].resources.limits.cpu先被转换为millicore值，再乘以100。其结果就是每100毫秒内容器可以使用的CPU时间总量，单位为微秒。在此期间（100ms），容器所使用的CPU时间不可以超过它被分配的时间。说明：默认的配额（Quota）周期为100毫秒。CPU配额的最小精度为1毫秒。spec.containers[].resources.limits.memory被转换为整数值，作为dockerrun命令中的--memory参数值。如果Container超过其内存限制，则可能会被终止。如果容器可重新启动，则与所有其他类型的运行时失效一样，kubelet将重新启动容器。如果一个Container内存用量超过其内存请求值，那么当节点内存不足时，容器所处的Pod可能被逐出。每个Container可能被允许也可能不被允许使用超过其CPU约束的处理时间。但是，容器不会由于CPU使用率过高而被杀死。要确定Container是否会由于资源约束而无法调度或被杀死，请参阅疑难解答部分。监控计算和内存资源用量Pod的资源使用情况是作为Pod状态的一部分来报告的。如果为集群配置了可选的监控工具，则可以直接从指标API或者监控工具获得Pod的资源使用情况。本地临时存储FEATURESTATE:Kubernetesv1.10[beta]节点通常还可以具有本地的临时性存储，由本地挂接的可写入设备或者有时也用RAM来提供支持。“临时（Ephemeral）”意味着对所存储的数据不提供长期可用性的保证。Pods通常可以使用临时性本地存储来实现缓冲区、保存日志等功能。kubelet可以为使用本地临时存储的Pods提供这种存储空间，允许后者使用emptyDir类型的卷将其挂载到容器中。kubelet也使用此类存储来保存节点层面的容器日志，容器镜像文件、以及运行中容器的可写入层。注意：如果节点失效，存储在临时性存储中的数据会丢失。你的应用不能对本地临时性存储的性能SLA（例如磁盘IOPS）作任何假定。作为一种beta阶段功能特性，Kubernetes允许你跟踪、预留和限制Pod可消耗的临时性本地存储数量。本地临时性存储的配置Kubernetes有两种方式支持节点上配置本地临时性存储：单一文件系统双文件系统采用这种配置时，你会把所有类型的临时性本地数据（包括emptyDir卷、可写入容器层、容器镜像、日志等）放到同一个文件系统中。作为最有效的kubelet配置方式，这意味着该文件系统是专门提供给Kubernetes（kubelet）来保存数据的。kubelet也会生成节点层面的容器日志，并按临时性本地存储的方式对待之。kubelet会将日志写入到所配置的日志目录（默认为/var/log）下的文件中；还会针对其他本地存储的数据使用同一个基础目录（默认为/var/lib/kubelet）。通常，/var/lib/kubelet和/var/log都是在系统的根文件系统中。kubelet的设计也考虑到这一点。你的集群节点当然可以包含其他的、并非用于Kubernetes的很多文件系统。kubelet能够度量其本地存储的用量。实现度量机制的前提是：LocalStorageCapacityIsolation特性门控被启用（默认状态），并且你已经对节点进行了配置，使之使用所支持的本地临时性储存配置方式之一如果你的节点配置不同于以上预期，kubelet就无法对临时性本地存储的资源约束实施限制。说明：kubelet会将tmpfsemptyDir卷的用量当作容器内存用量，而不是本地临时性存储来统计。为本地临时性存储设置请求和约束值你可以使用ephemeral-storage来管理本地临时性存储。Pod中的每个Container可以设置以下属性：spec.containers[].resources.limits.ephemeral-storagespec.containers[].resources.requests.ephemeral-storageephemeral-storage的请求和约束值是按字节计量的。你可以使用一般整数或者定点数字加上下面的后缀来表达存储量：E、P、T、G、M、K。你也可以使用对应的2的幂级数来表达：Ei、Pi、Ti、Gi、Mi、Ki。例如，下面的表达式所表达的大致是同一个值：128974848,129e6,129M,123Mi在下面的例子中，Pod包含两个Container。每个Container请求2GiB大小的本地临时性存储。每个Container都设置了4GiB作为其本地临时性存储的约束值。因此，整个Pod的本地临时性存储请求是4GiB，且其本地临时性存储的约束为8GiB。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmp-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmpvolumes:-name:ephemeralemptyDir:{}带临时性存储的Pods的调度行为当你创建一个Pod时，Kubernetes调度器会为Pod选择一个节点来运行之。每个节点都有一个本地临时性存储的上限，是其可提供给Pods使用的总量。欲了解更多信息，可参考节点可分配资源节。调度器会确保所调度的Containers的资源请求总和不会超出节点的资源容量。临时性存储消耗的管理如果kubelet将本地临时性存储作为资源来管理，则kubelet会度量以下各处的存储用量：emptyDir卷，除了tmpfsemptyDir卷保存节点层面日志的目录可写入的容器镜像层如果某Pod的临时存储用量超出了你所允许的范围，kubelet会向其发出逐出（eviction）信号，触发该Pod被逐出所在节点。就容器层面的隔离而言，如果某容器的可写入镜像层和日志用量超出其存储约束，kubelet也会将所在的Pod标记为逐出候选。就Pod层面的隔离而言，kubelet会将Pod中所有容器的约束值相加，得到Pod存储约束的总值。如果所有容器的本地临时性存储用量总和加上Pod的emptyDir卷的用量超出Pod存储约束值，kubelet也会将该Pod标记为逐出候选。注意：如果kubelet没有度量本地临时性存储的用量，即使Pod的本地存储用量超出其约束值也不会被逐出。不过，如果用于可写入容器镜像层、节点层面日志或者emptyDir卷的文件系统中可用空间太少，节点会为自身设置本地存储不足的污点标签。这一污点会触发对那些无法容忍该污点的Pods的逐出操作。关于临时性本地存储的配置信息，请参考这里kubelet支持使用不同方式来度量Pod的存储用量：周期性扫描文件系统项目配额kubelet按预定周期执行扫描操作，检查emptyDir卷、容器日志目录以及可写入容器镜像层。这一扫描会度量存储空间用量。说明：在这种模式下，kubelet并不检查已删除文件所对应的、仍处于打开状态的文件描述符。如果你（或者容器）在emptyDir卷中创建了一个文件，写入一些内容之后再次打开该文件并执行了删除操作，所删除文件对应的inode仍然存在，直到你关闭该文件为止。kubelet不会将该文件所占用的空间视为已使用空间。为容器管理资源当你定义Pod时可以选择性地为每个容器设定所需要的资源数量。最常见的可设定资源是CPU和内存（RAM）大小；此外还有其他类型的资源。当你为Pod中的Container指定了资源请求时，调度器就利用该信息决定将Pod调度到哪个节点上。当你还为Container指定了资源约束时，kubelet就可以确保运行的容器不会使用超出所设约束的资源。kubelet还会为容器预留所请求数量的系统资源，供其使用。请求和约束如果Pod运行所在的节点具有足够的可用资源，容器可能（且可以）使用超出对应资源request属性所设置的资源量。不过，容器不可以使用超出其资源limit属性所设置的资源量。例如，如果你将容器的memory的请求量设置为256MiB，而该容器所处的Pod被调度到一个具有8GiB内存的节点上，并且该节点上没有其他Pods运行，那么该容器就可以尝试使用更多的内存。如果你将某容器的memory约束设置为4GiB，kubelet（和容器运行时）就会确保该约束生效。容器运行时会禁止容器使用超出所设置资源约束的资源。例如：当容器中进程尝试使用超出所允许内存量的资源时，系统内核会将尝试申请内存的进程终止，并引发内存不足（OOM）错误。约束值可以以被动方式来实现（系统会在发现违例时进行干预），或者通过强制生效的方式实现（系统会避免容器用量超出约束值）。不同的容器运行时采用不同方式来实现相同的限制。说明：如果某Container设置了自己的内存限制但未设置内存请求，Kubernetes自动为其设置与内存限制相匹配的请求值。类似的，如果某Container设置了CPU限制值但未设置CPU请求值，则Kubernetes自动为其设置CPU请求并使之与CPU限制值匹配。资源类型CPU和内存都是资源类型。每种资源类型具有其基本单位。CPU表达的是计算处理能力，其单位是KubernetesCPUs。内存的单位是字节。如果你使用的是Kubernetesv1.14或更高版本，则可以指定巨页（HugePage）资源。巨页是Linux特有的功能，节点内核在其中分配的内存块比默认页大小大得多。例如，在默认页面大小为4KiB的系统上，你可以指定约束hugepages-2Mi:80Mi。如果容器尝试分配40个2MiB大小的巨页（总共80MiB），则分配请求会失败。说明：你不能过量使用hugepages-*资源。这与memory和cpu资源不同。CPU和内存统称为计算资源，或简称为资源。计算资源的数量是可测量的，可以被请求、被分配、被消耗。它们与API资源不同。API资源（如Pod和Service）是可通过KubernetesAPI服务器读取和修改的对象。Pod和容器的资源请求和约束Pod中的每个容器都可以指定以下的一个或者多个值：spec.containers[].resources.limits.cpuspec.containers[].resources.limits.memoryspec.containers[].resources.limits.hugepages-<size>spec.containers[].resources.requests.cpuspec.containers[].resources.requests.memoryspec.containers[].resources.requests.hugepages-<size>尽管请求和限制值只能在单个容器上指定，我们仍可方便地计算出Pod的资源请求和约束。Pod对特定资源类型的请求/约束值是Pod中各容器对该类型资源的请求/约束值的总和。Kubernetes中的资源单位CPU的含义CPU资源的约束和请求以CPU为单位。Kubernetes中的一个CPU等于云平台上的1个vCPU/核和裸机Intel处理器上的1个超线程。你也可以表达带小数CPU的请求。spec.containers[].resources.requests.cpu为0.5的Container肯定能够获得请求1CPU的容器的一半CPU资源。表达式0.1等价于表达式100m，可以看作“100millicpu”。有些人说成是“一百毫cpu”，其实说的是同样的事情。具有小数点（如0.1）的请求由API转换为100m；最大精度是1m。因此，或许你应该优先考虑使用100m的形式。CPU总是按绝对数量来请求的，不可以使用相对数量；0.1的CPU在单核、双核、48核的机器上的意义是一样的。内存的含义内存的约束和请求以字节为单位。你可以使用以下后缀之一以一般整数或定点数字形式来表示内存：E、P、T、G、M、k。你也可以使用对应的2的幂数：Ei、Pi、Ti、Gi、Mi、Ki。例如，以下表达式所代表的是大致相同的值：128974848、129e6、129M、123Mi下面是个例子。以下Pod有两个Container。每个Container的请求为0.25cpu和64MiB（226字节）内存，每个容器的资源约束为0.5cpu和128MiB内存。你可以认为该Pod的资源请求为0.5cpu和128MiB内存，资源限制为1cpu和256MiB内存。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4env:-name:MYSQL_ROOT_PASSWORDvalue:passwordresources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m带资源请求的Pod如何调度当你创建一个Pod时，Kubernetes调度程序将为Pod选择一个节点。每个节点对每种资源类型都有一个容量上限：可为Pod提供的CPU和内存量。调度程序确保对于每种资源类型，所调度的容器的资源请求的总和小于节点的容量。请注意，尽管节点上的实际内存或CPU资源使用量非常低，如果容量检查失败，调度程序仍会拒绝在该节点上放置Pod。当稍后节点上资源用量增加，例如到达请求率的每日峰值区间时，节点上也不会出现资源不足的问题。带资源约束的Pod如何运行当kubelet启动Pod中的Container时，它会将CPU和内存约束信息传递给容器运行时。当使用Docker时：spec.containers[].resources.requests.cpu先被转换为可能是小数的基础值，再乘以1024。这个数值和2的较大者用作dockerrun命令中的--cpu-shares标志的值。spec.containers[].resources.limits.cpu先被转换为millicore值，再乘以100。其结果就是每100毫秒内容器可以使用的CPU时间总量，单位为微秒。在此期间（100ms），容器所使用的CPU时间不可以超过它被分配的时间。说明：默认的配额（Quota）周期为100毫秒。CPU配额的最小精度为1毫秒。spec.containers[].resources.limits.memory被转换为整数值，作为dockerrun命令中的--memory参数值。如果Container超过其内存限制，则可能会被终止。如果容器可重新启动，则与所有其他类型的运行时失效一样，kubelet将重新启动容器。如果一个Container内存用量超过其内存请求值，那么当节点内存不足时，容器所处的Pod可能被逐出。每个Container可能被允许也可能不被允许使用超过其CPU约束的处理时间。但是，容器不会由于CPU使用率过高而被杀死。要确定Container是否会由于资源约束而无法调度或被杀死，请参阅疑难解答部分。监控计算和内存资源用量Pod的资源使用情况是作为Pod状态的一部分来报告的。如果为集群配置了可选的监控工具，则可以直接从指标API或者监控工具获得Pod的资源使用情况。本地临时存储FEATURESTATE:Kubernetesv1.10[beta]节点通常还可以具有本地的临时性存储，由本地挂接的可写入设备或者有时也用RAM来提供支持。“临时（Ephemeral）”意味着对所存储的数据不提供长期可用性的保证。Pods通常可以使用临时性本地存储来实现缓冲区、保存日志等功能。kubelet可以为使用本地临时存储的Pods提供这种存储空间，允许后者使用emptyDir类型的卷将其挂载到容器中。kubelet也使用此类存储来保存节点层面的容器日志，容器镜像文件、以及运行中容器的可写入层。注意：如果节点失效，存储在临时性存储中的数据会丢失。你的应用不能对本地临时性存储的性能SLA（例如磁盘IOPS）作任何假定。作为一种beta阶段功能特性，Kubernetes允许你跟踪、预留和限制Pod可消耗的临时性本地存储数量。本地临时性存储的配置Kubernetes有两种方式支持节点上配置本地临时性存储：单一文件系统双文件系统采用这种配置时，你会把所有类型的临时性本地数据（包括emptyDir卷、可写入容器层、容器镜像、日志等）放到同一个文件系统中。作为最有效的kubelet配置方式，这意味着该文件系统是专门提供给Kubernetes（kubelet）来保存数据的。kubelet也会生成节点层面的容器日志，并按临时性本地存储的方式对待之。kubelet会将日志写入到所配置的日志目录（默认为/var/log）下的文件中；还会针对其他本地存储的数据使用同一个基础目录（默认为/var/lib/kubelet）。通常，/var/lib/kubelet和/var/log都是在系统的根文件系统中。kubelet的设计也考虑到这一点。你的集群节点当然可以包含其他的、并非用于Kubernetes的很多文件系统。kubelet能够度量其本地存储的用量。实现度量机制的前提是：LocalStorageCapacityIsolation特性门控被启用（默认状态），并且你已经对节点进行了配置，使之使用所支持的本地临时性储存配置方式之一如果你的节点配置不同于以上预期，kubelet就无法对临时性本地存储的资源约束实施限制。说明：kubelet会将tmpfsemptyDir卷的用量当作容器内存用量，而不是本地临时性存储来统计。为本地临时性存储设置请求和约束值你可以使用ephemeral-storage来管理本地临时性存储。Pod中的每个Container可以设置以下属性：spec.containers[].resources.limits.ephemeral-storagespec.containers[].resources.requests.ephemeral-storageephemeral-storage的请求和约束值是按字节计量的。你可以使用一般整数或者定点数字加上下面的后缀来表达存储量：E、P、T、G、M、K。你也可以使用对应的2的幂级数来表达：Ei、Pi、Ti、Gi、Mi、Ki。例如，下面的表达式所表达的大致是同一个值：128974848,129e6,129M,123Mi在下面的例子中，Pod包含两个Container。每个Container请求2GiB大小的本地临时性存储。每个Container都设置了4GiB作为其本地临时性存储的约束值。因此，整个Pod的本地临时性存储请求是4GiB，且其本地临时性存储的约束为8GiB。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmp-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmpvolumes:-name:ephemeralemptyDir:{}带临时性存储的Pods的调度行为当你创建一个Pod时，Kubernetes调度器会为Pod选择一个节点来运行之。每个节点都有一个本地临时性存储的上限，是其可提供给Pods使用的总量。欲了解更多信息，可参考节点可分配资源节。调度器会确保所调度的Containers的资源请求总和不会超出节点的资源容量。临时性存储消耗的管理如果kubelet将本地临时性存储作为资源来管理，则kubelet会度量以下各处的存储用量：emptyDir卷，除了tmpfsemptyDir卷保存节点层面日志的目录可写入的容器镜像层如果某Pod的临时存储用量超出了你所允许的范围，kubelet会向其发出逐出（eviction）信号，触发该Pod被逐出所在节点。就容器层面的隔离而言，如果某容器的可写入镜像层和日志用量超出其存储约束，kubelet也会将所在的Pod标记为逐出候选。就Pod层面的隔离而言，kubelet会将Pod中所有容器的约束值相加，得到Pod存储约束的总值。如果所有容器的本地临时性存储用量总和加上Pod的emptyDir卷的用量超出Pod存储约束值，kubelet也会将该Pod标记为逐出候选。注意：如果kubelet没有度量本地临时性存储的用量，即使Pod的本地存储用量超出其约束值也不会被逐出。不过，如果用于可写入容器镜像层、节点层面日志或者emptyDir卷的文件系统中可用空间太少，节点会为自身设置本地存储不足的污点标签。这一污点会触发对那些无法容忍该污点的Pods的逐出操作。关于临时性本地存储的配置信息，请参考这里kubelet支持使用不同方式来度量Pod的存储用量：周期性扫描文件系统项目配额kubelet按预定周期执行扫描操作，检查emptyDir卷、容器日志目录以及可写入容器镜像层。这一扫描会度量存储空间用量。说明：在这种模式下，kubelet并不检查已删除文件所对应的、仍处于打开状态的文件描述符。如果你（或者容器）在emptyDir卷中创建了一个文件，写入一些内容之后再次打开该文件并执行了删除操作，所删除文件对应的inode仍然存在，直到你关闭该文件为止。kubelet不会将该文件所占用的空间视为已使用空间。为容器管理资源当你定义Pod时可以选择性地为每个容器设定所需要的资源数量。最常见的可设定资源是CPU和内存（RAM）大小；此外还有其他类型的资源。当你为Pod中的Container指定了资源请求时，调度器就利用该信息决定将Pod调度到哪个节点上。当你还为Container指定了资源约束时，kubelet就可以确保运行的容器不会使用超出所设约束的资源。kubelet还会为容器预留所请求数量的系统资源，供其使用。请求和约束如果Pod运行所在的节点具有足够的可用资源，容器可能（且可以）使用超出对应资源request属性所设置的资源量。不过，容器不可以使用超出其资源limit属性所设置的资源量。例如，如果你将容器的memory的请求量设置为256MiB，而该容器所处的Pod被调度到一个具有8GiB内存的节点上，并且该节点上没有其他Pods运行，那么该容器就可以尝试使用更多的内存。如果你将某容器的memory约束设置为4GiB，kubelet（和容器运行时）就会确保该约束生效。容器运行时会禁止容器使用超出所设置资源约束的资源。例如：当容器中进程尝试使用超出所允许内存量的资源时，系统内核会将尝试申请内存的进程终止，并引发内存不足（OOM）错误。约束值可以以被动方式来实现（系统会在发现违例时进行干预），或者通过强制生效的方式实现（系统会避免容器用量超出约束值）。不同的容器运行时采用不同方式来实现相同的限制。说明：如果某Container设置了自己的内存限制但未设置内存请求，Kubernetes自动为其设置与内存限制相匹配的请求值。类似的，如果某Container设置了CPU限制值但未设置CPU请求值，则Kubernetes自动为其设置CPU请求并使之与CPU限制值匹配。资源类型CPU和内存都是资源类型。每种资源类型具有其基本单位。CPU表达的是计算处理能力，其单位是KubernetesCPUs。内存的单位是字节。如果你使用的是Kubernetesv1.14或更高版本，则可以指定巨页（HugePage）资源。巨页是Linux特有的功能，节点内核在其中分配的内存块比默认页大小大得多。例如，在默认页面大小为4KiB的系统上，你可以指定约束hugepages-2Mi:80Mi。如果容器尝试分配40个2MiB大小的巨页（总共80MiB），则分配请求会失败。说明：你不能过量使用hugepages-*资源。这与memory和cpu资源不同。CPU和内存统称为计算资源，或简称为资源。计算资源的数量是可测量的，可以被请求、被分配、被消耗。它们与API资源不同。API资源（如Pod和Service）是可通过KubernetesAPI服务器读取和修改的对象。Pod和容器的资源请求和约束Pod中的每个容器都可以指定以下的一个或者多个值：spec.containers[].resources.limits.cpuspec.containers[].resources.limits.memoryspec.containers[].resources.limits.hugepages-<size>spec.containers[].resources.requests.cpuspec.containers[].resources.requests.memoryspec.containers[].resources.requests.hugepages-<size>尽管请求和限制值只能在单个容器上指定，我们仍可方便地计算出Pod的资源请求和约束。Pod对特定资源类型的请求/约束值是Pod中各容器对该类型资源的请求/约束值的总和。Kubernetes中的资源单位CPU的含义CPU资源的约束和请求以CPU为单位。Kubernetes中的一个CPU等于云平台上的1个vCPU/核和裸机Intel处理器上的1个超线程。你也可以表达带小数CPU的请求。spec.containers[].resources.requests.cpu为0.5的Container肯定能够获得请求1CPU的容器的一半CPU资源。表达式0.1等价于表达式100m，可以看作“100millicpu”。有些人说成是“一百毫cpu”，其实说的是同样的事情。具有小数点（如0.1）的请求由API转换为100m；最大精度是1m。因此，或许你应该优先考虑使用100m的形式。CPU总是按绝对数量来请求的，不可以使用相对数量；0.1的CPU在单核、双核、48核的机器上的意义是一样的。内存的含义内存的约束和请求以字节为单位。你可以使用以下后缀之一以一般整数或定点数字形式来表示内存：E、P、T、G、M、k。你也可以使用对应的2的幂数：Ei、Pi、Ti、Gi、Mi、Ki。例如，以下表达式所代表的是大致相同的值：128974848、129e6、129M、123Mi下面是个例子。以下Pod有两个Container。每个Container的请求为0.25cpu和64MiB（226字节）内存，每个容器的资源约束为0.5cpu和128MiB内存。你可以认为该Pod的资源请求为0.5cpu和128MiB内存，资源限制为1cpu和256MiB内存。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4env:-name:MYSQL_ROOT_PASSWORDvalue:passwordresources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:memory:64Micpu:250mlimits:memory:128Micpu:500m带资源请求的Pod如何调度当你创建一个Pod时，Kubernetes调度程序将为Pod选择一个节点。每个节点对每种资源类型都有一个容量上限：可为Pod提供的CPU和内存量。调度程序确保对于每种资源类型，所调度的容器的资源请求的总和小于节点的容量。请注意，尽管节点上的实际内存或CPU资源使用量非常低，如果容量检查失败，调度程序仍会拒绝在该节点上放置Pod。当稍后节点上资源用量增加，例如到达请求率的每日峰值区间时，节点上也不会出现资源不足的问题。带资源约束的Pod如何运行当kubelet启动Pod中的Container时，它会将CPU和内存约束信息传递给容器运行时。当使用Docker时：spec.containers[].resources.requests.cpu先被转换为可能是小数的基础值，再乘以1024。这个数值和2的较大者用作dockerrun命令中的--cpu-shares标志的值。spec.containers[].resources.limits.cpu先被转换为millicore值，再乘以100。其结果就是每100毫秒内容器可以使用的CPU时间总量，单位为微秒。在此期间（100ms），容器所使用的CPU时间不可以超过它被分配的时间。说明：默认的配额（Quota）周期为100毫秒。CPU配额的最小精度为1毫秒。spec.containers[].resources.limits.memory被转换为整数值，作为dockerrun命令中的--memory参数值。如果Container超过其内存限制，则可能会被终止。如果容器可重新启动，则与所有其他类型的运行时失效一样，kubelet将重新启动容器。如果一个Container内存用量超过其内存请求值，那么当节点内存不足时，容器所处的Pod可能被逐出。每个Container可能被允许也可能不被允许使用超过其CPU约束的处理时间。但是，容器不会由于CPU使用率过高而被杀死。要确定Container是否会由于资源约束而无法调度或被杀死，请参阅疑难解答部分。监控计算和内存资源用量Pod的资源使用情况是作为Pod状态的一部分来报告的。如果为集群配置了可选的监控工具，则可以直接从指标API或者监控工具获得Pod的资源使用情况。本地临时存储FEATURESTATE:Kubernetesv1.10[beta]节点通常还可以具有本地的临时性存储，由本地挂接的可写入设备或者有时也用RAM来提供支持。“临时（Ephemeral）”意味着对所存储的数据不提供长期可用性的保证。Pods通常可以使用临时性本地存储来实现缓冲区、保存日志等功能。kubelet可以为使用本地临时存储的Pods提供这种存储空间，允许后者使用emptyDir类型的卷将其挂载到容器中。kubelet也使用此类存储来保存节点层面的容器日志，容器镜像文件、以及运行中容器的可写入层。注意：如果节点失效，存储在临时性存储中的数据会丢失。你的应用不能对本地临时性存储的性能SLA（例如磁盘IOPS）作任何假定。作为一种beta阶段功能特性，Kubernetes允许你跟踪、预留和限制Pod可消耗的临时性本地存储数量。本地临时性存储的配置Kubernetes有两种方式支持节点上配置本地临时性存储：单一文件系统双文件系统采用这种配置时，你会把所有类型的临时性本地数据（包括emptyDir卷、可写入容器层、容器镜像、日志等）放到同一个文件系统中。作为最有效的kubelet配置方式，这意味着该文件系统是专门提供给Kubernetes（kubelet）来保存数据的。kubelet也会生成节点层面的容器日志，并按临时性本地存储的方式对待之。kubelet会将日志写入到所配置的日志目录（默认为/var/log）下的文件中；还会针对其他本地存储的数据使用同一个基础目录（默认为/var/lib/kubelet）。通常，/var/lib/kubelet和/var/log都是在系统的根文件系统中。kubelet的设计也考虑到这一点。你的集群节点当然可以包含其他的、并非用于Kubernetes的很多文件系统。kubelet能够度量其本地存储的用量。实现度量机制的前提是：LocalStorageCapacityIsolation特性门控被启用（默认状态），并且你已经对节点进行了配置，使之使用所支持的本地临时性储存配置方式之一如果你的节点配置不同于以上预期，kubelet就无法对临时性本地存储的资源约束实施限制。说明：kubelet会将tmpfsemptyDir卷的用量当作容器内存用量，而不是本地临时性存储来统计。为本地临时性存储设置请求和约束值你可以使用ephemeral-storage来管理本地临时性存储。Pod中的每个Container可以设置以下属性：spec.containers[].resources.limits.ephemeral-storagespec.containers[].resources.requests.ephemeral-storageephemeral-storage的请求和约束值是按字节计量的。你可以使用一般整数或者定点数字加上下面的后缀来表达存储量：E、P、T、G、M、K。你也可以使用对应的2的幂级数来表达：Ei、Pi、Ti、Gi、Mi、Ki。例如，下面的表达式所表达的大致是同一个值：128974848,129e6,129M,123Mi在下面的例子中，Pod包含两个Container。每个Container请求2GiB大小的本地临时性存储。每个Container都设置了4GiB作为其本地临时性存储的约束值。因此，整个Pod的本地临时性存储请求是4GiB，且其本地临时性存储的约束为8GiB。apiVersion:v1kind:Podmetadata:name:frontendspec:containers:-name:appimage:images.my-company.example/app:v4resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmp-name:log-aggregatorimage:images.my-company.example/log-aggregator:v6resources:requests:ephemeral-storage:2Gilimits:ephemeral-storage:4GivolumeMounts:-name:ephemeralmountPath:/tmpvolumes:-name:ephemeralemptyDir:{}带临时性存储的Pods的调度行为当你创建一个Pod时，Kubernetes调度器会为Pod选择一个节点来运行之。每个节点都有一个本地临时性存储的上限，是其可提供给Pods使用的总量。欲了解更多信息，可参考节点可分配资源节。调度器会确保所调度的Containers的资源请求总和不会超出节点的资源容量。临时性存储消耗的管理如果kubelet将本地临时性存储作为资源来管理，则kubelet会度量以下各处的存储用量：emptyDir卷，除了tmpfsemptyDir卷保存节点层面日志的目录可写入的容器镜像层如果某Pod的临时存储用量超出了你所允许的范围，kubelet会向其发出逐出（eviction）信号，触发该Pod被逐出所在节点。就容器层面的隔离而言，如果某容器的可写入镜像层和日志用量超出其存储约束，kubelet也会将所在的Pod标记为逐出候选。就Pod层面的隔离而言，kubelet会将Pod中所有容器的约束值相加，得到Pod存储约束的总值。如果所有容器的本地临时性存储用量总和加上Pod的emptyDir卷的用量超出Pod存储约束值，kubelet也会将该Pod标记为逐出候选。注意：如果kubelet没有度量本地临时性存储的用量，即使Pod的本地存储用量超出其约束值也不会被逐出。不过，如果用于可写入容器镜像层、节点层面日志或者emptyDir卷的文件系统中可用空间太少，节点会为自身设置本地存储不足的污点标签。这一污点会触发对那些无法容忍该污点的Pods的逐出操作。关于临时性本地存储的配置信息，请参考这里kubelet支持使用不同方式来度量Pod的存储用量：周期性扫描文件系统项目配额kubelet按预定周期执行扫描操作，检查emptyDir卷、容器日志目录以及可写入容器镜像层。这一扫描会度量存储空间用量。说明：在这种模式下，kubelet并不检查已删除文件所对应的、仍处于打开状态的文件描述符。如果你（或者容器）在emptyDir卷中创建了一个文件，写入一些内容之后再次打开该文件并执行了删除操作，所删除文件对应的inode仍然存在，直到你关闭该文件为止。kubelet不会将该文件所占用的空间视为已使用空间。";
        TextMessage message = session.createTextMessage("生产者的消息数据------时刻：" + nowTime + "------编号：" + i + "==============" + text);

        message.setLongProperty(ScheduledMessage.AMQ_SCHEDULED_DELAY, 60000L); //设置延迟时间
        message.setLongProperty(ScheduledMessage.AMQ_SCHEDULED_PERIOD, 3000L); //设置重复投递间隔（非必要，根据实际情况）
        message.setLongProperty(ScheduledMessage.AMQ_SCHEDULED_REPEAT, 5L); //重复投递次数（非必要，根据实际情况）

        producer.send(message);
        System.out.println("向队列中发送消息：【生产者的消息数据------时刻：" + nowTime + "------编号：" + i + "】");
    }

    public void close() throws JMSException {
        producer.close();
        session.close();
        connection.close();
    }

    public static void main(String[] args) {
        try {

            Producer producer = new Producer();
            int i = 1;
            while (true) {
                producer.sendMessage(String.valueOf(i));
                System.out.println("生产者生产数据完毕--------" + i);
                Thread.sleep(10);
                i++;
                if (i > 1) {
                    break;
                }
            }

        } catch (JMSException | InterruptedException e) {
            e.printStackTrace();
        }
    }

}
